Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* jsonb.c
|
|
|
|
* I/O routines for jsonb type
|
|
|
|
*
|
2018-01-03 05:30:12 +01:00
|
|
|
* Copyright (c) 2014-2018, PostgreSQL Global Development Group
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
|
|
|
* src/backend/utils/adt/jsonb.c
|
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
#include "miscadmin.h"
|
|
|
|
#include "access/htup_details.h"
|
|
|
|
#include "access/transam.h"
|
|
|
|
#include "catalog/pg_type.h"
|
2017-10-25 13:34:00 +02:00
|
|
|
#include "funcapi.h"
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
#include "libpq/pqformat.h"
|
2014-12-12 21:31:14 +01:00
|
|
|
#include "parser/parse_coerce.h"
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
#include "utils/builtins.h"
|
2014-12-12 21:31:14 +01:00
|
|
|
#include "utils/date.h"
|
|
|
|
#include "utils/datetime.h"
|
|
|
|
#include "utils/lsyscache.h"
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
#include "utils/json.h"
|
|
|
|
#include "utils/jsonapi.h"
|
|
|
|
#include "utils/jsonb.h"
|
2014-12-12 21:31:14 +01:00
|
|
|
#include "utils/syscache.h"
|
|
|
|
#include "utils/typcache.h"
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
typedef struct JsonbInState
|
|
|
|
{
|
|
|
|
JsonbParseState *parseState;
|
|
|
|
JsonbValue *res;
|
2014-05-06 18:12:18 +02:00
|
|
|
} JsonbInState;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
/* unlike with json categories, we need to treat json and jsonb differently */
|
|
|
|
typedef enum /* type categories for datum_to_jsonb */
|
|
|
|
{
|
|
|
|
JSONBTYPE_NULL, /* null, so we didn't bother to identify */
|
|
|
|
JSONBTYPE_BOOL, /* boolean (built-in types only) */
|
|
|
|
JSONBTYPE_NUMERIC, /* numeric (ditto) */
|
|
|
|
JSONBTYPE_DATE, /* we use special formatting for datetimes */
|
|
|
|
JSONBTYPE_TIMESTAMP, /* we use special formatting for timestamp */
|
|
|
|
JSONBTYPE_TIMESTAMPTZ, /* ... and timestamptz */
|
|
|
|
JSONBTYPE_JSON, /* JSON */
|
|
|
|
JSONBTYPE_JSONB, /* JSONB */
|
|
|
|
JSONBTYPE_ARRAY, /* array */
|
|
|
|
JSONBTYPE_COMPOSITE, /* composite */
|
|
|
|
JSONBTYPE_JSONCAST, /* something with an explicit cast to JSON */
|
|
|
|
JSONBTYPE_OTHER /* all else */
|
2015-05-24 03:35:49 +02:00
|
|
|
} JsonbTypeCategory;
|
2014-12-12 21:31:14 +01:00
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
typedef struct JsonbAggState
|
|
|
|
{
|
2015-10-15 19:46:09 +02:00
|
|
|
JsonbInState *res;
|
|
|
|
JsonbTypeCategory key_category;
|
|
|
|
Oid key_output_func;
|
|
|
|
JsonbTypeCategory val_category;
|
|
|
|
Oid val_output_func;
|
2015-09-18 20:39:39 +02:00
|
|
|
} JsonbAggState;
|
|
|
|
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
static inline Datum jsonb_from_cstring(char *json, int len);
|
|
|
|
static size_t checkStringLen(size_t len);
|
|
|
|
static void jsonb_in_object_start(void *pstate);
|
|
|
|
static void jsonb_in_object_end(void *pstate);
|
|
|
|
static void jsonb_in_array_start(void *pstate);
|
|
|
|
static void jsonb_in_array_end(void *pstate);
|
|
|
|
static void jsonb_in_object_field_start(void *pstate, char *fname, bool isnull);
|
2014-05-06 18:12:18 +02:00
|
|
|
static void jsonb_put_escaped_value(StringInfo out, JsonbValue *scalarVal);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
static void jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype);
|
2014-12-12 21:31:14 +01:00
|
|
|
static void jsonb_categorize_type(Oid typoid,
|
2015-05-24 03:35:49 +02:00
|
|
|
JsonbTypeCategory *tcategory,
|
2014-12-12 21:31:14 +01:00
|
|
|
Oid *outfuncoid);
|
|
|
|
static void composite_to_jsonb(Datum composite, JsonbInState *result);
|
|
|
|
static void array_dim_to_jsonb(JsonbInState *result, int dim, int ndims, int *dims,
|
|
|
|
Datum *vals, bool *nulls, int *valcount,
|
|
|
|
JsonbTypeCategory tcategory, Oid outfuncoid);
|
|
|
|
static void array_to_jsonb_internal(Datum array, JsonbInState *result);
|
|
|
|
static void jsonb_categorize_type(Oid typoid,
|
2015-05-24 03:35:49 +02:00
|
|
|
JsonbTypeCategory *tcategory,
|
2014-12-12 21:31:14 +01:00
|
|
|
Oid *outfuncoid);
|
|
|
|
static void datum_to_jsonb(Datum val, bool is_null, JsonbInState *result,
|
|
|
|
JsonbTypeCategory tcategory, Oid outfuncoid,
|
|
|
|
bool key_scalar);
|
|
|
|
static void add_jsonb(Datum val, bool is_null, JsonbInState *result,
|
|
|
|
Oid val_type, bool key_scalar);
|
2015-05-24 03:35:49 +02:00
|
|
|
static JsonbParseState *clone_parse_state(JsonbParseState *state);
|
2015-05-12 21:52:45 +02:00
|
|
|
static char *JsonbToCStringWorker(StringInfo out, JsonbContainer *in, int estimated_len, bool indent);
|
|
|
|
static void add_indent(StringInfo out, bool indent, int level);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* jsonb type input function
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_in(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
char *json = PG_GETARG_CSTRING(0);
|
|
|
|
|
|
|
|
return jsonb_from_cstring(json, strlen(json));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* jsonb type recv function
|
|
|
|
*
|
|
|
|
* The type is sent as text in binary mode, so this is almost the same
|
|
|
|
* as the input function, but it's prefixed with a version number so we
|
|
|
|
* can change the binary format sent in future if necessary. For now,
|
|
|
|
* only version 1 is supported.
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_recv(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
|
|
|
|
int version = pq_getmsgint(buf, 1);
|
|
|
|
char *str;
|
|
|
|
int nbytes;
|
|
|
|
|
|
|
|
if (version == 1)
|
|
|
|
str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
|
|
|
|
else
|
2014-05-07 22:16:19 +02:00
|
|
|
elog(ERROR, "unsupported jsonb version number %d", version);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
return jsonb_from_cstring(str, nbytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* jsonb type output function
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_out(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2017-09-18 21:21:23 +02:00
|
|
|
Jsonb *jb = PG_GETARG_JSONB_P(0);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
char *out;
|
|
|
|
|
2014-05-07 22:16:19 +02:00
|
|
|
out = JsonbToCString(NULL, &jb->root, VARSIZE(jb));
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
PG_RETURN_CSTRING(out);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* jsonb type send function
|
|
|
|
*
|
|
|
|
* Just send jsonb as a version number, then a string of text
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_send(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2017-09-18 21:21:23 +02:00
|
|
|
Jsonb *jb = PG_GETARG_JSONB_P(0);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
StringInfoData buf;
|
|
|
|
StringInfo jtext = makeStringInfo();
|
|
|
|
int version = 1;
|
|
|
|
|
2014-05-07 22:16:19 +02:00
|
|
|
(void) JsonbToCString(jtext, &jb->root, VARSIZE(jb));
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
pq_begintypsend(&buf);
|
2017-10-12 06:00:46 +02:00
|
|
|
pq_sendint8(&buf, version);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
pq_sendtext(&buf, jtext->data, jtext->len);
|
|
|
|
pfree(jtext->data);
|
|
|
|
pfree(jtext);
|
|
|
|
|
|
|
|
PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SQL function jsonb_typeof(jsonb) -> text
|
|
|
|
*
|
|
|
|
* This function is here because the analog json function is in json.c, since
|
|
|
|
* it uses the json parser internals not exposed elsewhere.
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_typeof(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2017-09-18 21:21:23 +02:00
|
|
|
Jsonb *in = PG_GETARG_JSONB_P(0);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
JsonbIterator *it;
|
|
|
|
JsonbValue v;
|
|
|
|
char *result;
|
|
|
|
|
|
|
|
if (JB_ROOT_IS_OBJECT(in))
|
|
|
|
result = "object";
|
|
|
|
else if (JB_ROOT_IS_ARRAY(in) && !JB_ROOT_IS_SCALAR(in))
|
|
|
|
result = "array";
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Assert(JB_ROOT_IS_SCALAR(in));
|
|
|
|
|
2014-05-07 22:16:19 +02:00
|
|
|
it = JsonbIteratorInit(&in->root);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A root scalar is stored as an array of one element, so we get the
|
|
|
|
* array and then its first (and only) member.
|
|
|
|
*/
|
|
|
|
(void) JsonbIteratorNext(&it, &v, true);
|
|
|
|
Assert(v.type == jbvArray);
|
|
|
|
(void) JsonbIteratorNext(&it, &v, true);
|
|
|
|
switch (v.type)
|
|
|
|
{
|
|
|
|
case jbvNull:
|
|
|
|
result = "null";
|
|
|
|
break;
|
|
|
|
case jbvString:
|
|
|
|
result = "string";
|
|
|
|
break;
|
|
|
|
case jbvNumeric:
|
|
|
|
result = "number";
|
|
|
|
break;
|
|
|
|
case jbvBool:
|
|
|
|
result = "boolean";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
elog(ERROR, "unknown jsonb scalar type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PG_RETURN_TEXT_P(cstring_to_text(result));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* jsonb_from_cstring
|
|
|
|
*
|
|
|
|
* Turns json string into a jsonb Datum.
|
|
|
|
*
|
|
|
|
* Uses the json parser (with hooks) to construct a jsonb.
|
|
|
|
*/
|
|
|
|
static inline Datum
|
|
|
|
jsonb_from_cstring(char *json, int len)
|
|
|
|
{
|
|
|
|
JsonLexContext *lex;
|
|
|
|
JsonbInState state;
|
|
|
|
JsonSemAction sem;
|
|
|
|
|
|
|
|
memset(&state, 0, sizeof(state));
|
|
|
|
memset(&sem, 0, sizeof(sem));
|
|
|
|
lex = makeJsonLexContextCstringLen(json, len, true);
|
|
|
|
|
|
|
|
sem.semstate = (void *) &state;
|
|
|
|
|
|
|
|
sem.object_start = jsonb_in_object_start;
|
|
|
|
sem.array_start = jsonb_in_array_start;
|
|
|
|
sem.object_end = jsonb_in_object_end;
|
|
|
|
sem.array_end = jsonb_in_array_end;
|
|
|
|
sem.scalar = jsonb_in_scalar;
|
|
|
|
sem.object_field_start = jsonb_in_object_field_start;
|
|
|
|
|
|
|
|
pg_parse_json(lex, &sem);
|
|
|
|
|
|
|
|
/* after parsing, the item member has the composed jsonb structure */
|
|
|
|
PG_RETURN_POINTER(JsonbValueToJsonb(state.res));
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
checkStringLen(size_t len)
|
|
|
|
{
|
Change JSONB's on-disk format for improved performance.
The original design used an array of offsets into the variable-length
portion of a JSONB container. However, such an array is basically
uncompressible by simple compression techniques such as TOAST's LZ
compressor. That's bad enough, but because the offset array is at the
front, it tended to trigger the give-up-after-1KB heuristic in the TOAST
code, so that the entire JSONB object was stored uncompressed; which was
the root cause of bug #11109 from Larry White.
To fix without losing the ability to extract a random array element in O(1)
time, change this scheme so that most of the JEntry array elements hold
lengths rather than offsets. With data that's compressible at all, there
tend to be fewer distinct element lengths, so that there is scope for
compression of the JEntry array. Every N'th entry is still an offset.
To determine the length or offset of any specific element, we might have
to examine up to N preceding JEntrys, but that's still O(1) so far as the
total container size is concerned. Testing shows that this cost is
negligible compared to other costs of accessing a JSONB field, and that
the method does largely fix the incompressible-data problem.
While at it, rearrange the order of elements in a JSONB object so that
it's "all the keys, then all the values" not alternating keys and values.
This doesn't really make much difference right at the moment, but it will
allow providing a fast path for extracting individual object fields from
large JSONB values stored EXTERNAL (ie, uncompressed), analogously to the
existing optimization for substring extraction from large EXTERNAL text
values.
Bump catversion to denote the incompatibility in on-disk format.
We will need to fix pg_upgrade to disallow upgrading jsonb data stored
with 9.4 betas 1 and 2.
Heikki Linnakangas and Tom Lane
2014-09-29 18:29:21 +02:00
|
|
|
if (len > JENTRY_OFFLENMASK)
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
|
|
|
|
errmsg("string too long to represent as jsonb string"),
|
|
|
|
errdetail("Due to an implementation restriction, jsonb strings cannot exceed %d bytes.",
|
Change JSONB's on-disk format for improved performance.
The original design used an array of offsets into the variable-length
portion of a JSONB container. However, such an array is basically
uncompressible by simple compression techniques such as TOAST's LZ
compressor. That's bad enough, but because the offset array is at the
front, it tended to trigger the give-up-after-1KB heuristic in the TOAST
code, so that the entire JSONB object was stored uncompressed; which was
the root cause of bug #11109 from Larry White.
To fix without losing the ability to extract a random array element in O(1)
time, change this scheme so that most of the JEntry array elements hold
lengths rather than offsets. With data that's compressible at all, there
tend to be fewer distinct element lengths, so that there is scope for
compression of the JEntry array. Every N'th entry is still an offset.
To determine the length or offset of any specific element, we might have
to examine up to N preceding JEntrys, but that's still O(1) so far as the
total container size is concerned. Testing shows that this cost is
negligible compared to other costs of accessing a JSONB field, and that
the method does largely fix the incompressible-data problem.
While at it, rearrange the order of elements in a JSONB object so that
it's "all the keys, then all the values" not alternating keys and values.
This doesn't really make much difference right at the moment, but it will
allow providing a fast path for extracting individual object fields from
large JSONB values stored EXTERNAL (ie, uncompressed), analogously to the
existing optimization for substring extraction from large EXTERNAL text
values.
Bump catversion to denote the incompatibility in on-disk format.
We will need to fix pg_upgrade to disallow upgrading jsonb data stored
with 9.4 betas 1 and 2.
Heikki Linnakangas and Tom Lane
2014-09-29 18:29:21 +02:00
|
|
|
JENTRY_OFFLENMASK)));
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
jsonb_in_object_start(void *pstate)
|
|
|
|
{
|
|
|
|
JsonbInState *_state = (JsonbInState *) pstate;
|
|
|
|
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_BEGIN_OBJECT, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
jsonb_in_object_end(void *pstate)
|
|
|
|
{
|
|
|
|
JsonbInState *_state = (JsonbInState *) pstate;
|
|
|
|
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_END_OBJECT, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
jsonb_in_array_start(void *pstate)
|
|
|
|
{
|
|
|
|
JsonbInState *_state = (JsonbInState *) pstate;
|
|
|
|
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_BEGIN_ARRAY, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
jsonb_in_array_end(void *pstate)
|
|
|
|
{
|
|
|
|
JsonbInState *_state = (JsonbInState *) pstate;
|
|
|
|
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_END_ARRAY, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
jsonb_in_object_field_start(void *pstate, char *fname, bool isnull)
|
|
|
|
{
|
|
|
|
JsonbInState *_state = (JsonbInState *) pstate;
|
|
|
|
JsonbValue v;
|
|
|
|
|
2014-05-06 18:12:18 +02:00
|
|
|
Assert(fname != NULL);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
v.type = jbvString;
|
2014-04-02 20:30:08 +02:00
|
|
|
v.val.string.len = checkStringLen(strlen(fname));
|
2014-05-09 10:32:28 +02:00
|
|
|
v.val.string.val = fname;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_KEY, &v);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-05-06 18:12:18 +02:00
|
|
|
jsonb_put_escaped_value(StringInfo out, JsonbValue *scalarVal)
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
{
|
|
|
|
switch (scalarVal->type)
|
|
|
|
{
|
|
|
|
case jbvNull:
|
|
|
|
appendBinaryStringInfo(out, "null", 4);
|
|
|
|
break;
|
|
|
|
case jbvString:
|
2014-04-02 20:30:08 +02:00
|
|
|
escape_json(out, pnstrdup(scalarVal->val.string.val, scalarVal->val.string.len));
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
break;
|
|
|
|
case jbvNumeric:
|
|
|
|
appendStringInfoString(out,
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
DatumGetCString(DirectFunctionCall1(numeric_out,
|
|
|
|
PointerGetDatum(scalarVal->val.numeric))));
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
break;
|
|
|
|
case jbvBool:
|
2014-04-02 20:30:08 +02:00
|
|
|
if (scalarVal->val.boolean)
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
appendBinaryStringInfo(out, "true", 4);
|
|
|
|
else
|
|
|
|
appendBinaryStringInfo(out, "false", 5);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
elog(ERROR, "unknown jsonb scalar type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For jsonb we always want the de-escaped value - that's what's in token
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
jsonb_in_scalar(void *pstate, char *token, JsonTokenType tokentype)
|
|
|
|
{
|
|
|
|
JsonbInState *_state = (JsonbInState *) pstate;
|
|
|
|
JsonbValue v;
|
|
|
|
|
|
|
|
switch (tokentype)
|
|
|
|
{
|
|
|
|
|
|
|
|
case JSON_TOKEN_STRING:
|
2014-05-06 18:12:18 +02:00
|
|
|
Assert(token != NULL);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
v.type = jbvString;
|
2014-04-02 20:30:08 +02:00
|
|
|
v.val.string.len = checkStringLen(strlen(token));
|
2014-05-09 10:32:28 +02:00
|
|
|
v.val.string.val = token;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
break;
|
|
|
|
case JSON_TOKEN_NUMBER:
|
2014-05-06 18:12:18 +02:00
|
|
|
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
/*
|
2014-05-06 18:12:18 +02:00
|
|
|
* No need to check size of numeric values, because maximum
|
|
|
|
* numeric size is well below the JsonbValue restriction
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
*/
|
2014-05-06 18:12:18 +02:00
|
|
|
Assert(token != NULL);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
v.type = jbvNumeric;
|
2014-04-02 20:30:08 +02:00
|
|
|
v.val.numeric = DatumGetNumeric(DirectFunctionCall3(numeric_in, CStringGetDatum(token), 0, -1));
|
2014-05-06 18:12:18 +02:00
|
|
|
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
break;
|
|
|
|
case JSON_TOKEN_TRUE:
|
|
|
|
v.type = jbvBool;
|
2014-04-02 20:30:08 +02:00
|
|
|
v.val.boolean = true;
|
2015-05-24 03:35:49 +02:00
|
|
|
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
break;
|
|
|
|
case JSON_TOKEN_FALSE:
|
|
|
|
v.type = jbvBool;
|
2014-04-02 20:30:08 +02:00
|
|
|
v.val.boolean = false;
|
2015-05-24 03:35:49 +02:00
|
|
|
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
break;
|
|
|
|
case JSON_TOKEN_NULL:
|
|
|
|
v.type = jbvNull;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* should not be possible */
|
|
|
|
elog(ERROR, "invalid json token type");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_state->parseState == NULL)
|
|
|
|
{
|
|
|
|
/* single scalar */
|
|
|
|
JsonbValue va;
|
|
|
|
|
|
|
|
va.type = jbvArray;
|
2014-04-02 20:30:08 +02:00
|
|
|
va.val.array.rawScalar = true;
|
|
|
|
va.val.array.nElems = 1;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_BEGIN_ARRAY, &va);
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_ELEM, &v);
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_END_ARRAY, NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
JsonbValue *o = &_state->parseState->contVal;
|
|
|
|
|
|
|
|
switch (o->type)
|
|
|
|
{
|
|
|
|
case jbvArray:
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_ELEM, &v);
|
|
|
|
break;
|
|
|
|
case jbvObject:
|
|
|
|
_state->res = pushJsonbValue(&_state->parseState, WJB_VALUE, &v);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
elog(ERROR, "unexpected parent of nested structure");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JsonbToCString
|
|
|
|
* Converts jsonb value to a C-string.
|
|
|
|
*
|
|
|
|
* If 'out' argument is non-null, the resulting C-string is stored inside the
|
|
|
|
* StringBuffer. The resulting string is always returned.
|
|
|
|
*
|
|
|
|
* A typical case for passing the StringInfo in rather than NULL is where the
|
|
|
|
* caller wants access to the len attribute without having to call strlen, e.g.
|
|
|
|
* if they are converting it to a text* object.
|
|
|
|
*/
|
|
|
|
char *
|
2014-05-07 22:16:19 +02:00
|
|
|
JsonbToCString(StringInfo out, JsonbContainer *in, int estimated_len)
|
2015-05-12 21:52:45 +02:00
|
|
|
{
|
|
|
|
return JsonbToCStringWorker(out, in, estimated_len, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* same thing but with indentation turned on
|
|
|
|
*/
|
|
|
|
char *
|
|
|
|
JsonbToCStringIndent(StringInfo out, JsonbContainer *in, int estimated_len)
|
|
|
|
{
|
|
|
|
return JsonbToCStringWorker(out, in, estimated_len, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* common worker for above two functions
|
|
|
|
*/
|
|
|
|
static char *
|
|
|
|
JsonbToCStringWorker(StringInfo out, JsonbContainer *in, int estimated_len, bool indent)
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
{
|
|
|
|
bool first = true;
|
|
|
|
JsonbIterator *it;
|
|
|
|
JsonbValue v;
|
2015-10-12 05:53:35 +02:00
|
|
|
JsonbIteratorToken type = WJB_DONE;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
int level = 0;
|
|
|
|
bool redo_switch = false;
|
2015-05-24 03:35:49 +02:00
|
|
|
|
2015-05-12 21:52:45 +02:00
|
|
|
/* If we are indenting, don't add a space after a comma */
|
|
|
|
int ispaces = indent ? 1 : 2;
|
2015-05-24 03:35:49 +02:00
|
|
|
|
2015-05-12 21:52:45 +02:00
|
|
|
/*
|
2015-05-24 03:35:49 +02:00
|
|
|
* Don't indent the very first item. This gets set to the indent flag at
|
|
|
|
* the bottom of the loop.
|
2015-05-12 21:52:45 +02:00
|
|
|
*/
|
2015-05-24 03:35:49 +02:00
|
|
|
bool use_indent = false;
|
|
|
|
bool raw_scalar = false;
|
|
|
|
bool last_was_key = false;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
|
|
|
if (out == NULL)
|
|
|
|
out = makeStringInfo();
|
|
|
|
|
|
|
|
enlargeStringInfo(out, (estimated_len >= 0) ? estimated_len : 64);
|
|
|
|
|
|
|
|
it = JsonbIteratorInit(in);
|
|
|
|
|
|
|
|
while (redo_switch ||
|
|
|
|
((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE))
|
|
|
|
{
|
|
|
|
redo_switch = false;
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case WJB_BEGIN_ARRAY:
|
|
|
|
if (!first)
|
2015-05-12 21:52:45 +02:00
|
|
|
appendBinaryStringInfo(out, ", ", ispaces);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
2014-04-02 20:30:08 +02:00
|
|
|
if (!v.val.array.rawScalar)
|
2015-05-12 21:52:45 +02:00
|
|
|
{
|
|
|
|
add_indent(out, use_indent && !last_was_key, level);
|
|
|
|
appendStringInfoCharMacro(out, '[');
|
|
|
|
}
|
|
|
|
else
|
|
|
|
raw_scalar = true;
|
|
|
|
|
|
|
|
first = true;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
level++;
|
|
|
|
break;
|
|
|
|
case WJB_BEGIN_OBJECT:
|
|
|
|
if (!first)
|
2015-05-12 21:52:45 +02:00
|
|
|
appendBinaryStringInfo(out, ", ", ispaces);
|
|
|
|
|
|
|
|
add_indent(out, use_indent && !last_was_key, level);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
appendStringInfoCharMacro(out, '{');
|
|
|
|
|
2015-05-12 21:52:45 +02:00
|
|
|
first = true;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
level++;
|
|
|
|
break;
|
|
|
|
case WJB_KEY:
|
|
|
|
if (!first)
|
2015-05-12 21:52:45 +02:00
|
|
|
appendBinaryStringInfo(out, ", ", ispaces);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
first = true;
|
|
|
|
|
2015-05-12 21:52:45 +02:00
|
|
|
add_indent(out, use_indent, level);
|
|
|
|
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
/* json rules guarantee this is a string */
|
|
|
|
jsonb_put_escaped_value(out, &v);
|
|
|
|
appendBinaryStringInfo(out, ": ", 2);
|
|
|
|
|
|
|
|
type = JsonbIteratorNext(&it, &v, false);
|
|
|
|
if (type == WJB_VALUE)
|
|
|
|
{
|
|
|
|
first = false;
|
|
|
|
jsonb_put_escaped_value(out, &v);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Assert(type == WJB_BEGIN_OBJECT || type == WJB_BEGIN_ARRAY);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to rerun the current switch() since we need to
|
|
|
|
* output the object which we just got from the iterator
|
|
|
|
* before calling the iterator again.
|
|
|
|
*/
|
|
|
|
redo_switch = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WJB_ELEM:
|
|
|
|
if (!first)
|
2015-05-12 21:52:45 +02:00
|
|
|
appendBinaryStringInfo(out, ", ", ispaces);
|
|
|
|
first = false;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
|
2015-05-24 03:35:49 +02:00
|
|
|
if (!raw_scalar)
|
2015-05-12 21:52:45 +02:00
|
|
|
add_indent(out, use_indent, level);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
jsonb_put_escaped_value(out, &v);
|
|
|
|
break;
|
|
|
|
case WJB_END_ARRAY:
|
|
|
|
level--;
|
2015-05-24 03:35:49 +02:00
|
|
|
if (!raw_scalar)
|
2015-05-12 21:52:45 +02:00
|
|
|
{
|
|
|
|
add_indent(out, use_indent, level);
|
|
|
|
appendStringInfoCharMacro(out, ']');
|
|
|
|
}
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
first = false;
|
|
|
|
break;
|
|
|
|
case WJB_END_OBJECT:
|
|
|
|
level--;
|
2015-05-12 21:52:45 +02:00
|
|
|
add_indent(out, use_indent, level);
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
appendStringInfoCharMacro(out, '}');
|
|
|
|
first = false;
|
|
|
|
break;
|
|
|
|
default:
|
2015-02-27 22:54:49 +01:00
|
|
|
elog(ERROR, "unknown jsonb iterator token type");
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
}
|
2015-05-12 21:52:45 +02:00
|
|
|
use_indent = indent;
|
|
|
|
last_was_key = redo_switch;
|
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.
The new type has all the functions and operators that the json type has,
with the exception of the json generation functions (to_json, json_agg etc.)
and with identical semantics. In addition, there are operator classes for
hash and btree indexing, and two classes for GIN indexing, that have no
equivalent in the json type.
This feature grew out of previous work by Oleg Bartunov and Teodor Sigaev, which
was intended to provide similar facilities to a nested hstore type, but which
in the end proved to have some significant compatibility issues.
Authors: Oleg Bartunov, Teodor Sigaev, Peter Geoghegan and Andrew Dunstan.
Review: Andres Freund
2014-03-23 21:40:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Assert(level == 0);
|
|
|
|
|
|
|
|
return out->data;
|
|
|
|
}
|
2014-12-12 21:31:14 +01:00
|
|
|
|
2015-05-12 21:52:45 +02:00
|
|
|
static void
|
|
|
|
add_indent(StringInfo out, bool indent, int level)
|
|
|
|
{
|
|
|
|
if (indent)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
appendStringInfoCharMacro(out, '\n');
|
|
|
|
for (i = 0; i < level; i++)
|
|
|
|
appendBinaryStringInfo(out, " ", 4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine how we want to render values of a given type in datum_to_jsonb.
|
|
|
|
*
|
|
|
|
* Given the datatype OID, return its JsonbTypeCategory, as well as the type's
|
|
|
|
* output function OID. If the returned category is JSONBTYPE_JSONCAST,
|
2015-05-24 21:04:10 +02:00
|
|
|
* we return the OID of the relevant cast function instead.
|
2014-12-12 21:31:14 +01:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
jsonb_categorize_type(Oid typoid,
|
2015-05-24 03:35:49 +02:00
|
|
|
JsonbTypeCategory *tcategory,
|
2014-12-12 21:31:14 +01:00
|
|
|
Oid *outfuncoid)
|
|
|
|
{
|
|
|
|
bool typisvarlena;
|
|
|
|
|
|
|
|
/* Look through any domain */
|
|
|
|
typoid = getBaseType(typoid);
|
|
|
|
|
|
|
|
*outfuncoid = InvalidOid;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to get the output function for everything except date and
|
|
|
|
* timestamp types, booleans, array and composite types, json and jsonb,
|
|
|
|
* and non-builtin types where there's a cast to json. In this last case
|
|
|
|
* we return the oid of the cast function instead.
|
|
|
|
*/
|
|
|
|
|
|
|
|
switch (typoid)
|
|
|
|
{
|
|
|
|
case BOOLOID:
|
|
|
|
*tcategory = JSONBTYPE_BOOL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case INT2OID:
|
|
|
|
case INT4OID:
|
|
|
|
case INT8OID:
|
|
|
|
case FLOAT4OID:
|
|
|
|
case FLOAT8OID:
|
|
|
|
case NUMERICOID:
|
|
|
|
getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
|
|
|
|
*tcategory = JSONBTYPE_NUMERIC;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DATEOID:
|
|
|
|
*tcategory = JSONBTYPE_DATE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TIMESTAMPOID:
|
|
|
|
*tcategory = JSONBTYPE_TIMESTAMP;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TIMESTAMPTZOID:
|
|
|
|
*tcategory = JSONBTYPE_TIMESTAMPTZ;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case JSONBOID:
|
|
|
|
*tcategory = JSONBTYPE_JSONB;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case JSONOID:
|
|
|
|
*tcategory = JSONBTYPE_JSON;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* Check for arrays and composites */
|
2017-02-22 17:10:49 +01:00
|
|
|
if (OidIsValid(get_element_type(typoid)) || typoid == ANYARRAYOID
|
|
|
|
|| typoid == RECORDARRAYOID)
|
2014-12-12 21:31:14 +01:00
|
|
|
*tcategory = JSONBTYPE_ARRAY;
|
2017-05-17 22:31:56 +02:00
|
|
|
else if (type_is_rowtype(typoid)) /* includes RECORDOID */
|
2014-12-12 21:31:14 +01:00
|
|
|
*tcategory = JSONBTYPE_COMPOSITE;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* It's probably the general case ... */
|
|
|
|
*tcategory = JSONBTYPE_OTHER;
|
|
|
|
|
|
|
|
/*
|
2015-05-24 03:35:49 +02:00
|
|
|
* but first let's look for a cast to json (note: not to
|
|
|
|
* jsonb) if it's not built-in.
|
2014-12-12 21:31:14 +01:00
|
|
|
*/
|
|
|
|
if (typoid >= FirstNormalObjectId)
|
|
|
|
{
|
2015-05-24 03:35:49 +02:00
|
|
|
Oid castfunc;
|
2014-12-12 21:31:14 +01:00
|
|
|
CoercionPathType ctype;
|
|
|
|
|
|
|
|
ctype = find_coercion_pathway(JSONOID, typoid,
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
COERCION_EXPLICIT, &castfunc);
|
2014-12-12 21:31:14 +01:00
|
|
|
if (ctype == COERCION_PATH_FUNC && OidIsValid(castfunc))
|
|
|
|
{
|
|
|
|
*tcategory = JSONBTYPE_JSONCAST;
|
|
|
|
*outfuncoid = castfunc;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* not a cast type, so just get the usual output func */
|
|
|
|
getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* any other builtin type */
|
|
|
|
getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Turn a Datum into jsonb, adding it to the result JsonbInState.
|
|
|
|
*
|
|
|
|
* tcategory and outfuncoid are from a previous call to json_categorize_type,
|
|
|
|
* except that if is_null is true then they can be invalid.
|
|
|
|
*
|
|
|
|
* If key_scalar is true, the value is stored as a key, so insist
|
|
|
|
* it's of an acceptable type, and force it to be a jbvString.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
datum_to_jsonb(Datum val, bool is_null, JsonbInState *result,
|
|
|
|
JsonbTypeCategory tcategory, Oid outfuncoid,
|
|
|
|
bool key_scalar)
|
|
|
|
{
|
|
|
|
char *outputstr;
|
|
|
|
bool numeric_error;
|
|
|
|
JsonbValue jb;
|
|
|
|
bool scalar_jsonb = false;
|
|
|
|
|
2015-10-05 16:06:29 +02:00
|
|
|
check_stack_depth();
|
|
|
|
|
2015-10-15 19:46:09 +02:00
|
|
|
/* Convert val to a JsonbValue in jb (in most cases) */
|
2014-12-12 21:31:14 +01:00
|
|
|
if (is_null)
|
|
|
|
{
|
2015-07-24 15:40:46 +02:00
|
|
|
Assert(!key_scalar);
|
2014-12-12 21:31:14 +01:00
|
|
|
jb.type = jbvNull;
|
|
|
|
}
|
|
|
|
else if (key_scalar &&
|
|
|
|
(tcategory == JSONBTYPE_ARRAY ||
|
|
|
|
tcategory == JSONBTYPE_COMPOSITE ||
|
|
|
|
tcategory == JSONBTYPE_JSON ||
|
|
|
|
tcategory == JSONBTYPE_JSONB ||
|
|
|
|
tcategory == JSONBTYPE_JSONCAST))
|
|
|
|
{
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
errmsg("key value must be scalar, not array, composite, or json")));
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (tcategory == JSONBTYPE_JSONCAST)
|
|
|
|
val = OidFunctionCall1(outfuncoid, val);
|
|
|
|
|
|
|
|
switch (tcategory)
|
|
|
|
{
|
|
|
|
case JSONBTYPE_ARRAY:
|
|
|
|
array_to_jsonb_internal(val, result);
|
|
|
|
break;
|
|
|
|
case JSONBTYPE_COMPOSITE:
|
|
|
|
composite_to_jsonb(val, result);
|
|
|
|
break;
|
|
|
|
case JSONBTYPE_BOOL:
|
|
|
|
if (key_scalar)
|
|
|
|
{
|
|
|
|
outputstr = DatumGetBool(val) ? "true" : "false";
|
|
|
|
jb.type = jbvString;
|
|
|
|
jb.val.string.len = strlen(outputstr);
|
|
|
|
jb.val.string.val = outputstr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
jb.type = jbvBool;
|
|
|
|
jb.val.boolean = DatumGetBool(val);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case JSONBTYPE_NUMERIC:
|
|
|
|
outputstr = OidOutputFunctionCall(outfuncoid, val);
|
|
|
|
if (key_scalar)
|
|
|
|
{
|
|
|
|
/* always quote keys */
|
|
|
|
jb.type = jbvString;
|
|
|
|
jb.val.string.len = strlen(outputstr);
|
|
|
|
jb.val.string.val = outputstr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Make it numeric if it's a valid JSON number, otherwise
|
|
|
|
* a string. Invalid numeric output will always have an
|
|
|
|
* 'N' or 'n' in it (I think).
|
|
|
|
*/
|
|
|
|
numeric_error = (strchr(outputstr, 'N') != NULL ||
|
|
|
|
strchr(outputstr, 'n') != NULL);
|
|
|
|
if (!numeric_error)
|
|
|
|
{
|
|
|
|
jb.type = jbvNumeric;
|
|
|
|
jb.val.numeric = DatumGetNumeric(DirectFunctionCall3(numeric_in, CStringGetDatum(outputstr), 0, -1));
|
|
|
|
|
|
|
|
pfree(outputstr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
jb.type = jbvString;
|
|
|
|
jb.val.string.len = strlen(outputstr);
|
|
|
|
jb.val.string.val = outputstr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2015-05-24 03:35:49 +02:00
|
|
|
case JSONBTYPE_DATE:
|
2018-01-17 01:07:13 +01:00
|
|
|
jb.type = jbvString;
|
|
|
|
jb.val.string.val = JsonEncodeDateTime(NULL, val, DATEOID);
|
|
|
|
jb.val.string.len = strlen(jb.val.string.val);
|
2015-05-24 03:35:49 +02:00
|
|
|
break;
|
2014-12-12 21:31:14 +01:00
|
|
|
case JSONBTYPE_TIMESTAMP:
|
2018-01-17 01:07:13 +01:00
|
|
|
jb.type = jbvString;
|
|
|
|
jb.val.string.val = JsonEncodeDateTime(NULL, val, TIMESTAMPOID);
|
|
|
|
jb.val.string.len = strlen(jb.val.string.val);
|
2014-12-12 21:31:14 +01:00
|
|
|
break;
|
|
|
|
case JSONBTYPE_TIMESTAMPTZ:
|
2018-01-17 01:07:13 +01:00
|
|
|
jb.type = jbvString;
|
|
|
|
jb.val.string.val = JsonEncodeDateTime(NULL, val, TIMESTAMPTZOID);
|
|
|
|
jb.val.string.len = strlen(jb.val.string.val);
|
2014-12-12 21:31:14 +01:00
|
|
|
break;
|
|
|
|
case JSONBTYPE_JSONCAST:
|
|
|
|
case JSONBTYPE_JSON:
|
|
|
|
{
|
|
|
|
/* parse the json right into the existing result object */
|
|
|
|
JsonLexContext *lex;
|
|
|
|
JsonSemAction sem;
|
2017-03-13 00:35:34 +01:00
|
|
|
text *json = DatumGetTextPP(val);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
lex = makeJsonLexContext(json, true);
|
|
|
|
|
|
|
|
memset(&sem, 0, sizeof(sem));
|
|
|
|
|
|
|
|
sem.semstate = (void *) result;
|
|
|
|
|
|
|
|
sem.object_start = jsonb_in_object_start;
|
|
|
|
sem.array_start = jsonb_in_array_start;
|
|
|
|
sem.object_end = jsonb_in_object_end;
|
|
|
|
sem.array_end = jsonb_in_array_end;
|
|
|
|
sem.scalar = jsonb_in_scalar;
|
|
|
|
sem.object_field_start = jsonb_in_object_field_start;
|
|
|
|
|
|
|
|
pg_parse_json(lex, &sem);
|
|
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case JSONBTYPE_JSONB:
|
|
|
|
{
|
2017-09-18 21:21:23 +02:00
|
|
|
Jsonb *jsonb = DatumGetJsonbP(val);
|
2014-12-12 21:31:14 +01:00
|
|
|
JsonbIterator *it;
|
|
|
|
|
|
|
|
it = JsonbIteratorInit(&jsonb->root);
|
|
|
|
|
|
|
|
if (JB_ROOT_IS_SCALAR(jsonb))
|
|
|
|
{
|
|
|
|
(void) JsonbIteratorNext(&it, &jb, true);
|
|
|
|
Assert(jb.type == jbvArray);
|
|
|
|
(void) JsonbIteratorNext(&it, &jb, true);
|
|
|
|
scalar_jsonb = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-10-12 05:53:35 +02:00
|
|
|
JsonbIteratorToken type;
|
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
while ((type = JsonbIteratorNext(&it, &jb, false))
|
|
|
|
!= WJB_DONE)
|
|
|
|
{
|
|
|
|
if (type == WJB_END_ARRAY || type == WJB_END_OBJECT ||
|
|
|
|
type == WJB_BEGIN_ARRAY || type == WJB_BEGIN_OBJECT)
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, NULL);
|
|
|
|
else
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, &jb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
outputstr = OidOutputFunctionCall(outfuncoid, val);
|
|
|
|
jb.type = jbvString;
|
|
|
|
jb.val.string.len = checkStringLen(strlen(outputstr));
|
|
|
|
jb.val.string.val = outputstr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-10-15 19:46:09 +02:00
|
|
|
|
|
|
|
/* Now insert jb into result, unless we did it recursively */
|
|
|
|
if (!is_null && !scalar_jsonb &&
|
|
|
|
tcategory >= JSONBTYPE_JSON && tcategory <= JSONBTYPE_JSONCAST)
|
2014-12-12 21:31:14 +01:00
|
|
|
{
|
|
|
|
/* work has been done recursively */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (result->parseState == NULL)
|
|
|
|
{
|
|
|
|
/* single root scalar */
|
|
|
|
JsonbValue va;
|
|
|
|
|
|
|
|
va.type = jbvArray;
|
|
|
|
va.val.array.rawScalar = true;
|
|
|
|
va.val.array.nElems = 1;
|
|
|
|
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_ARRAY, &va);
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_ELEM, &jb);
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_END_ARRAY, NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
JsonbValue *o = &result->parseState->contVal;
|
|
|
|
|
|
|
|
switch (o->type)
|
|
|
|
{
|
|
|
|
case jbvArray:
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_ELEM, &jb);
|
|
|
|
break;
|
|
|
|
case jbvObject:
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
key_scalar ? WJB_KEY : WJB_VALUE,
|
|
|
|
&jb);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
elog(ERROR, "unexpected parent of nested structure");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a single dimension of an array.
|
|
|
|
* If it's the innermost dimension, output the values, otherwise call
|
|
|
|
* ourselves recursively to process the next dimension.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
array_dim_to_jsonb(JsonbInState *result, int dim, int ndims, int *dims, Datum *vals,
|
|
|
|
bool *nulls, int *valcount, JsonbTypeCategory tcategory,
|
|
|
|
Oid outfuncoid)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
Assert(dim < ndims);
|
|
|
|
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_ARRAY, NULL);
|
|
|
|
|
|
|
|
for (i = 1; i <= dims[dim]; i++)
|
|
|
|
{
|
|
|
|
if (dim + 1 == ndims)
|
|
|
|
{
|
|
|
|
datum_to_jsonb(vals[*valcount], nulls[*valcount], result, tcategory,
|
|
|
|
outfuncoid, false);
|
|
|
|
(*valcount)++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
array_dim_to_jsonb(result, dim + 1, ndims, dims, vals, nulls,
|
|
|
|
valcount, tcategory, outfuncoid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_END_ARRAY, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Turn an array into JSON.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
array_to_jsonb_internal(Datum array, JsonbInState *result)
|
|
|
|
{
|
|
|
|
ArrayType *v = DatumGetArrayTypeP(array);
|
|
|
|
Oid element_type = ARR_ELEMTYPE(v);
|
|
|
|
int *dim;
|
|
|
|
int ndim;
|
|
|
|
int nitems;
|
|
|
|
int count = 0;
|
|
|
|
Datum *elements;
|
|
|
|
bool *nulls;
|
|
|
|
int16 typlen;
|
|
|
|
bool typbyval;
|
|
|
|
char typalign;
|
|
|
|
JsonbTypeCategory tcategory;
|
|
|
|
Oid outfuncoid;
|
|
|
|
|
|
|
|
ndim = ARR_NDIM(v);
|
|
|
|
dim = ARR_DIMS(v);
|
|
|
|
nitems = ArrayGetNItems(ndim, dim);
|
|
|
|
|
|
|
|
if (nitems <= 0)
|
|
|
|
{
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_ARRAY, NULL);
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_END_ARRAY, NULL);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
get_typlenbyvalalign(element_type,
|
|
|
|
&typlen, &typbyval, &typalign);
|
|
|
|
|
|
|
|
jsonb_categorize_type(element_type,
|
|
|
|
&tcategory, &outfuncoid);
|
|
|
|
|
|
|
|
deconstruct_array(v, element_type, typlen, typbyval,
|
|
|
|
typalign, &elements, &nulls,
|
|
|
|
&nitems);
|
|
|
|
|
|
|
|
array_dim_to_jsonb(result, 0, ndim, dim, elements, nulls, &count, tcategory,
|
|
|
|
outfuncoid);
|
|
|
|
|
|
|
|
pfree(elements);
|
|
|
|
pfree(nulls);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Turn a composite / record into JSON.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
composite_to_jsonb(Datum composite, JsonbInState *result)
|
|
|
|
{
|
|
|
|
HeapTupleHeader td;
|
|
|
|
Oid tupType;
|
|
|
|
int32 tupTypmod;
|
|
|
|
TupleDesc tupdesc;
|
|
|
|
HeapTupleData tmptup,
|
|
|
|
*tuple;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
td = DatumGetHeapTupleHeader(composite);
|
|
|
|
|
|
|
|
/* Extract rowtype info and find a tupdesc */
|
|
|
|
tupType = HeapTupleHeaderGetTypeId(td);
|
|
|
|
tupTypmod = HeapTupleHeaderGetTypMod(td);
|
|
|
|
tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
|
|
|
|
|
|
|
|
/* Build a temporary HeapTuple control structure */
|
|
|
|
tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
|
|
|
|
tmptup.t_data = td;
|
|
|
|
tuple = &tmptup;
|
|
|
|
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_OBJECT, NULL);
|
|
|
|
|
|
|
|
for (i = 0; i < tupdesc->natts; i++)
|
|
|
|
{
|
|
|
|
Datum val;
|
|
|
|
bool isnull;
|
|
|
|
char *attname;
|
|
|
|
JsonbTypeCategory tcategory;
|
|
|
|
Oid outfuncoid;
|
|
|
|
JsonbValue v;
|
2017-08-20 20:19:07 +02:00
|
|
|
Form_pg_attribute att = TupleDescAttr(tupdesc, i);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
2017-08-20 20:19:07 +02:00
|
|
|
if (att->attisdropped)
|
2014-12-12 21:31:14 +01:00
|
|
|
continue;
|
|
|
|
|
2017-08-20 20:19:07 +02:00
|
|
|
attname = NameStr(att->attname);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
v.type = jbvString;
|
|
|
|
/* don't need checkStringLen here - can't exceed maximum name length */
|
|
|
|
v.val.string.len = strlen(attname);
|
|
|
|
v.val.string.val = attname;
|
|
|
|
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_KEY, &v);
|
|
|
|
|
|
|
|
val = heap_getattr(tuple, i + 1, tupdesc, &isnull);
|
|
|
|
|
|
|
|
if (isnull)
|
|
|
|
{
|
|
|
|
tcategory = JSONBTYPE_NULL;
|
|
|
|
outfuncoid = InvalidOid;
|
|
|
|
}
|
|
|
|
else
|
2017-08-20 20:19:07 +02:00
|
|
|
jsonb_categorize_type(att->atttypid, &tcategory, &outfuncoid);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
datum_to_jsonb(val, isnull, result, tcategory, outfuncoid, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
result->res = pushJsonbValue(&result->parseState, WJB_END_OBJECT, NULL);
|
|
|
|
ReleaseTupleDesc(tupdesc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Append JSON text for "val" to "result".
|
|
|
|
*
|
|
|
|
* This is just a thin wrapper around datum_to_jsonb. If the same type will be
|
|
|
|
* printed many times, avoid using this; better to do the jsonb_categorize_type
|
|
|
|
* lookups only once.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
add_jsonb(Datum val, bool is_null, JsonbInState *result,
|
|
|
|
Oid val_type, bool key_scalar)
|
|
|
|
{
|
|
|
|
JsonbTypeCategory tcategory;
|
|
|
|
Oid outfuncoid;
|
|
|
|
|
|
|
|
if (val_type == InvalidOid)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("could not determine input data type")));
|
|
|
|
|
|
|
|
if (is_null)
|
|
|
|
{
|
|
|
|
tcategory = JSONBTYPE_NULL;
|
|
|
|
outfuncoid = InvalidOid;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
jsonb_categorize_type(val_type,
|
|
|
|
&tcategory, &outfuncoid);
|
|
|
|
|
|
|
|
datum_to_jsonb(val, is_null, result, tcategory, outfuncoid, key_scalar);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SQL function to_jsonb(anyvalue)
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
to_jsonb(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
Datum val = PG_GETARG_DATUM(0);
|
|
|
|
Oid val_type = get_fn_expr_argtype(fcinfo->flinfo, 0);
|
|
|
|
JsonbInState result;
|
|
|
|
JsonbTypeCategory tcategory;
|
|
|
|
Oid outfuncoid;
|
|
|
|
|
|
|
|
if (val_type == InvalidOid)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("could not determine input data type")));
|
|
|
|
|
|
|
|
jsonb_categorize_type(val_type,
|
|
|
|
&tcategory, &outfuncoid);
|
|
|
|
|
|
|
|
memset(&result, 0, sizeof(JsonbInState));
|
|
|
|
|
|
|
|
datum_to_jsonb(val, false, &result, tcategory, outfuncoid, false);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SQL function jsonb_build_object(variadic "any")
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_build_object(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2017-10-25 13:34:00 +02:00
|
|
|
int nargs;
|
2014-12-12 21:31:14 +01:00
|
|
|
int i;
|
|
|
|
JsonbInState result;
|
2017-10-25 13:34:00 +02:00
|
|
|
Datum *args;
|
|
|
|
bool *nulls;
|
|
|
|
Oid *types;
|
|
|
|
|
|
|
|
/* build argument values to build the object */
|
|
|
|
nargs = extract_variadic_args(fcinfo, 0, true, &args, &types, &nulls);
|
|
|
|
|
|
|
|
if (nargs < 0)
|
|
|
|
PG_RETURN_NULL();
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
if (nargs % 2 != 0)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
2017-10-25 13:34:00 +02:00
|
|
|
errmsg("argument list must have even number of elements"),
|
|
|
|
errhint("The arguments of jsonb_build_object() must consist of alternating keys and values.")));
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
memset(&result, 0, sizeof(JsonbInState));
|
|
|
|
|
|
|
|
result.res = pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);
|
|
|
|
|
|
|
|
for (i = 0; i < nargs; i += 2)
|
|
|
|
{
|
|
|
|
/* process key */
|
2017-10-25 13:34:00 +02:00
|
|
|
if (nulls[i])
|
2014-12-12 21:31:14 +01:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
2015-11-17 03:16:42 +01:00
|
|
|
errmsg("argument %d: key must not be null", i + 1)));
|
2014-12-12 21:31:14 +01:00
|
|
|
|
2017-10-25 13:34:00 +02:00
|
|
|
add_jsonb(args[i], false, &result, types[i], true);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
/* process value */
|
2017-10-25 13:34:00 +02:00
|
|
|
add_jsonb(args[i + 1], nulls[i + 1], &result, types[i + 1], false);
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* degenerate case of jsonb_build_object where it gets 0 arguments.
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_build_object_noargs(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
JsonbInState result;
|
|
|
|
|
|
|
|
memset(&result, 0, sizeof(JsonbInState));
|
|
|
|
|
2014-12-16 16:32:06 +01:00
|
|
|
(void) pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);
|
2014-12-12 21:31:14 +01:00
|
|
|
result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SQL function jsonb_build_array(variadic "any")
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_build_array(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2017-10-25 13:34:00 +02:00
|
|
|
int nargs;
|
2014-12-12 21:31:14 +01:00
|
|
|
int i;
|
|
|
|
JsonbInState result;
|
2017-10-25 13:34:00 +02:00
|
|
|
Datum *args;
|
|
|
|
bool *nulls;
|
|
|
|
Oid *types;
|
|
|
|
|
|
|
|
/* build argument values to build the array */
|
|
|
|
nargs = extract_variadic_args(fcinfo, 0, true, &args, &types, &nulls);
|
|
|
|
|
|
|
|
if (nargs < 0)
|
|
|
|
PG_RETURN_NULL();
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
memset(&result, 0, sizeof(JsonbInState));
|
|
|
|
|
|
|
|
result.res = pushJsonbValue(&result.parseState, WJB_BEGIN_ARRAY, NULL);
|
|
|
|
|
|
|
|
for (i = 0; i < nargs; i++)
|
2017-10-25 13:34:00 +02:00
|
|
|
add_jsonb(args[i], nulls[i], &result, types[i], false);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
result.res = pushJsonbValue(&result.parseState, WJB_END_ARRAY, NULL);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* degenerate case of jsonb_build_array where it gets 0 arguments.
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_build_array_noargs(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
JsonbInState result;
|
|
|
|
|
|
|
|
memset(&result, 0, sizeof(JsonbInState));
|
|
|
|
|
2014-12-16 16:32:06 +01:00
|
|
|
(void) pushJsonbValue(&result.parseState, WJB_BEGIN_ARRAY, NULL);
|
2014-12-12 21:31:14 +01:00
|
|
|
result.res = pushJsonbValue(&result.parseState, WJB_END_ARRAY, NULL);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SQL function jsonb_object(text[])
|
|
|
|
*
|
|
|
|
* take a one or two dimensional array of text as name value pairs
|
|
|
|
* for a jsonb object.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_object(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
ArrayType *in_array = PG_GETARG_ARRAYTYPE_P(0);
|
|
|
|
int ndims = ARR_NDIM(in_array);
|
|
|
|
Datum *in_datums;
|
|
|
|
bool *in_nulls;
|
|
|
|
int in_count,
|
|
|
|
count,
|
|
|
|
i;
|
|
|
|
JsonbInState result;
|
|
|
|
|
|
|
|
memset(&result, 0, sizeof(JsonbInState));
|
|
|
|
|
2014-12-16 16:32:06 +01:00
|
|
|
(void) pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
switch (ndims)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
goto close_object;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
if ((ARR_DIMS(in_array)[0]) % 2)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
|
|
|
|
errmsg("array must have even number of elements")));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
if ((ARR_DIMS(in_array)[1]) != 2)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
|
|
|
|
errmsg("array must have two columns")));
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
|
|
|
|
errmsg("wrong number of array subscripts")));
|
|
|
|
}
|
|
|
|
|
|
|
|
deconstruct_array(in_array,
|
|
|
|
TEXTOID, -1, false, 'i',
|
|
|
|
&in_datums, &in_nulls, &in_count);
|
|
|
|
|
|
|
|
count = in_count / 2;
|
|
|
|
|
|
|
|
for (i = 0; i < count; ++i)
|
|
|
|
{
|
|
|
|
JsonbValue v;
|
|
|
|
char *str;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (in_nulls[i * 2])
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
|
|
|
|
errmsg("null value not allowed for object key")));
|
|
|
|
|
|
|
|
str = TextDatumGetCString(in_datums[i * 2]);
|
|
|
|
len = strlen(str);
|
|
|
|
|
|
|
|
v.type = jbvString;
|
|
|
|
|
|
|
|
v.val.string.len = len;
|
|
|
|
v.val.string.val = str;
|
|
|
|
|
2014-12-16 16:32:06 +01:00
|
|
|
(void) pushJsonbValue(&result.parseState, WJB_KEY, &v);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
if (in_nulls[i * 2 + 1])
|
|
|
|
{
|
|
|
|
v.type = jbvNull;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
str = TextDatumGetCString(in_datums[i * 2 + 1]);
|
|
|
|
len = strlen(str);
|
|
|
|
|
|
|
|
v.type = jbvString;
|
|
|
|
|
|
|
|
v.val.string.len = len;
|
|
|
|
v.val.string.val = str;
|
|
|
|
}
|
|
|
|
|
2014-12-16 16:32:06 +01:00
|
|
|
(void) pushJsonbValue(&result.parseState, WJB_VALUE, &v);
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pfree(in_datums);
|
|
|
|
pfree(in_nulls);
|
|
|
|
|
|
|
|
close_object:
|
|
|
|
result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SQL function jsonb_object(text[], text[])
|
|
|
|
*
|
|
|
|
* take separate name and value arrays of text to construct a jsonb object
|
|
|
|
* pairwise.
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_object_two_arg(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(0);
|
|
|
|
ArrayType *val_array = PG_GETARG_ARRAYTYPE_P(1);
|
|
|
|
int nkdims = ARR_NDIM(key_array);
|
|
|
|
int nvdims = ARR_NDIM(val_array);
|
|
|
|
Datum *key_datums,
|
|
|
|
*val_datums;
|
|
|
|
bool *key_nulls,
|
|
|
|
*val_nulls;
|
|
|
|
int key_count,
|
|
|
|
val_count,
|
|
|
|
i;
|
|
|
|
JsonbInState result;
|
|
|
|
|
|
|
|
memset(&result, 0, sizeof(JsonbInState));
|
|
|
|
|
2014-12-16 16:32:06 +01:00
|
|
|
(void) pushJsonbValue(&result.parseState, WJB_BEGIN_OBJECT, NULL);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
if (nkdims > 1 || nkdims != nvdims)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
|
|
|
|
errmsg("wrong number of array subscripts")));
|
|
|
|
|
|
|
|
if (nkdims == 0)
|
2016-02-21 16:30:49 +01:00
|
|
|
goto close_object;
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
deconstruct_array(key_array,
|
|
|
|
TEXTOID, -1, false, 'i',
|
|
|
|
&key_datums, &key_nulls, &key_count);
|
|
|
|
|
|
|
|
deconstruct_array(val_array,
|
|
|
|
TEXTOID, -1, false, 'i',
|
|
|
|
&val_datums, &val_nulls, &val_count);
|
|
|
|
|
|
|
|
if (key_count != val_count)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
|
|
|
|
errmsg("mismatched array dimensions")));
|
|
|
|
|
|
|
|
for (i = 0; i < key_count; ++i)
|
|
|
|
{
|
|
|
|
JsonbValue v;
|
|
|
|
char *str;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (key_nulls[i])
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
|
|
|
|
errmsg("null value not allowed for object key")));
|
|
|
|
|
|
|
|
str = TextDatumGetCString(key_datums[i]);
|
|
|
|
len = strlen(str);
|
|
|
|
|
|
|
|
v.type = jbvString;
|
|
|
|
|
|
|
|
v.val.string.len = len;
|
|
|
|
v.val.string.val = str;
|
|
|
|
|
2014-12-16 16:32:06 +01:00
|
|
|
(void) pushJsonbValue(&result.parseState, WJB_KEY, &v);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
if (val_nulls[i])
|
|
|
|
{
|
|
|
|
v.type = jbvNull;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
str = TextDatumGetCString(val_datums[i]);
|
|
|
|
len = strlen(str);
|
|
|
|
|
|
|
|
v.type = jbvString;
|
|
|
|
|
|
|
|
v.val.string.len = len;
|
|
|
|
v.val.string.val = str;
|
|
|
|
}
|
|
|
|
|
2014-12-16 16:32:06 +01:00
|
|
|
(void) pushJsonbValue(&result.parseState, WJB_VALUE, &v);
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pfree(key_datums);
|
|
|
|
pfree(key_nulls);
|
|
|
|
pfree(val_datums);
|
|
|
|
pfree(val_nulls);
|
|
|
|
|
2016-02-21 16:30:49 +01:00
|
|
|
close_object:
|
|
|
|
result.res = pushJsonbValue(&result.parseState, WJB_END_OBJECT, NULL);
|
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
PG_RETURN_POINTER(JsonbValueToJsonb(result.res));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* shallow clone of a parse state, suitable for use in aggregate
|
|
|
|
* final functions that will only append to the values rather than
|
|
|
|
* change them.
|
|
|
|
*/
|
|
|
|
static JsonbParseState *
|
2015-05-24 03:35:49 +02:00
|
|
|
clone_parse_state(JsonbParseState *state)
|
2014-12-12 21:31:14 +01:00
|
|
|
{
|
2015-05-24 03:35:49 +02:00
|
|
|
JsonbParseState *result,
|
|
|
|
*icursor,
|
|
|
|
*ocursor;
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
if (state == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
result = palloc(sizeof(JsonbParseState));
|
|
|
|
icursor = state;
|
|
|
|
ocursor = result;
|
2015-05-24 03:35:49 +02:00
|
|
|
for (;;)
|
2014-12-12 21:31:14 +01:00
|
|
|
{
|
|
|
|
ocursor->contVal = icursor->contVal;
|
|
|
|
ocursor->size = icursor->size;
|
|
|
|
icursor = icursor->next;
|
|
|
|
if (icursor == NULL)
|
|
|
|
break;
|
2015-05-24 03:35:49 +02:00
|
|
|
ocursor->next = palloc(sizeof(JsonbParseState));
|
2014-12-12 21:31:14 +01:00
|
|
|
ocursor = ocursor->next;
|
|
|
|
}
|
|
|
|
ocursor->next = NULL;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* jsonb_agg aggregate function
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_agg_transfn(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
MemoryContext oldcontext,
|
|
|
|
aggcontext;
|
2015-09-18 20:39:39 +02:00
|
|
|
JsonbAggState *state;
|
2014-12-12 21:31:14 +01:00
|
|
|
JsonbInState elem;
|
|
|
|
Datum val;
|
|
|
|
JsonbInState *result;
|
|
|
|
bool single_scalar = false;
|
|
|
|
JsonbIterator *it;
|
|
|
|
Jsonb *jbelem;
|
|
|
|
JsonbValue v;
|
2015-02-27 22:54:49 +01:00
|
|
|
JsonbIteratorToken type;
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
if (!AggCheckCallContext(fcinfo, &aggcontext))
|
|
|
|
{
|
|
|
|
/* cannot be called directly because of internal-type argument */
|
|
|
|
elog(ERROR, "jsonb_agg_transfn called in non-aggregate context");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set up the accumulator on the first go round */
|
|
|
|
|
|
|
|
if (PG_ARGISNULL(0))
|
|
|
|
{
|
2015-10-15 19:46:09 +02:00
|
|
|
Oid arg_type = get_fn_expr_argtype(fcinfo->flinfo, 1);
|
2015-09-18 20:39:39 +02:00
|
|
|
|
|
|
|
if (arg_type == InvalidOid)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("could not determine input data type")));
|
|
|
|
|
|
|
|
oldcontext = MemoryContextSwitchTo(aggcontext);
|
|
|
|
state = palloc(sizeof(JsonbAggState));
|
2014-12-12 21:31:14 +01:00
|
|
|
result = palloc0(sizeof(JsonbInState));
|
2015-09-18 20:39:39 +02:00
|
|
|
state->res = result;
|
2014-12-12 21:31:14 +01:00
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
WJB_BEGIN_ARRAY, NULL);
|
2015-09-18 20:39:39 +02:00
|
|
|
MemoryContextSwitchTo(oldcontext);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
jsonb_categorize_type(arg_type, &state->val_category,
|
|
|
|
&state->val_output_func);
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-09-18 20:39:39 +02:00
|
|
|
state = (JsonbAggState *) PG_GETARG_POINTER(0);
|
|
|
|
result = state->res;
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
/* turn the argument into jsonb in the normal function context */
|
|
|
|
|
|
|
|
val = PG_ARGISNULL(1) ? (Datum) 0 : PG_GETARG_DATUM(1);
|
|
|
|
|
|
|
|
memset(&elem, 0, sizeof(JsonbInState));
|
|
|
|
|
|
|
|
datum_to_jsonb(val, PG_ARGISNULL(1), &elem, state->val_category,
|
|
|
|
state->val_output_func, false);
|
|
|
|
|
|
|
|
jbelem = JsonbValueToJsonb(elem.res);
|
|
|
|
|
|
|
|
/* switch to the aggregate context for accumulation operations */
|
|
|
|
|
|
|
|
oldcontext = MemoryContextSwitchTo(aggcontext);
|
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
it = JsonbIteratorInit(&jbelem->root);
|
|
|
|
|
|
|
|
while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
|
|
|
|
{
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case WJB_BEGIN_ARRAY:
|
|
|
|
if (v.val.array.rawScalar)
|
|
|
|
single_scalar = true;
|
|
|
|
else
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, NULL);
|
|
|
|
break;
|
|
|
|
case WJB_END_ARRAY:
|
|
|
|
if (!single_scalar)
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, NULL);
|
|
|
|
break;
|
|
|
|
case WJB_BEGIN_OBJECT:
|
|
|
|
case WJB_END_OBJECT:
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, NULL);
|
|
|
|
break;
|
|
|
|
case WJB_ELEM:
|
|
|
|
case WJB_KEY:
|
|
|
|
case WJB_VALUE:
|
|
|
|
if (v.type == jbvString)
|
|
|
|
{
|
2015-02-27 22:54:49 +01:00
|
|
|
/* copy string values in the aggregate context */
|
2015-03-31 14:12:27 +02:00
|
|
|
char *buf = palloc(v.val.string.len + 1);
|
2015-05-24 03:35:49 +02:00
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
snprintf(buf, v.val.string.len + 1, "%s", v.val.string.val);
|
|
|
|
v.val.string.val = buf;
|
|
|
|
}
|
|
|
|
else if (v.type == jbvNumeric)
|
|
|
|
{
|
|
|
|
/* same for numeric */
|
2015-05-24 03:35:49 +02:00
|
|
|
v.val.numeric =
|
2017-06-21 20:39:04 +02:00
|
|
|
DatumGetNumeric(DirectFunctionCall1(numeric_uplus,
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
NumericGetDatum(v.val.numeric)));
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, &v);
|
|
|
|
break;
|
2015-02-27 22:54:49 +01:00
|
|
|
default:
|
|
|
|
elog(ERROR, "unknown jsonb iterator token type");
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
PG_RETURN_POINTER(state);
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_agg_finalfn(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2015-09-18 20:39:39 +02:00
|
|
|
JsonbAggState *arg;
|
2014-12-12 21:31:14 +01:00
|
|
|
JsonbInState result;
|
|
|
|
Jsonb *out;
|
|
|
|
|
|
|
|
/* cannot be called directly because of internal-type argument */
|
|
|
|
Assert(AggCheckCallContext(fcinfo, NULL));
|
|
|
|
|
|
|
|
if (PG_ARGISNULL(0))
|
|
|
|
PG_RETURN_NULL(); /* returns null iff no input values */
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
arg = (JsonbAggState *) PG_GETARG_POINTER(0);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to do a shallow clone of the argument in case the final
|
2015-05-24 03:35:49 +02:00
|
|
|
* function is called more than once, so we avoid changing the argument. A
|
|
|
|
* shallow clone is sufficient as we aren't going to change any of the
|
2014-12-12 21:31:14 +01:00
|
|
|
* values, just add the final array end marker.
|
|
|
|
*/
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
result.parseState = clone_parse_state(arg->res->parseState);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
result.res = pushJsonbValue(&result.parseState,
|
2015-05-24 03:35:49 +02:00
|
|
|
WJB_END_ARRAY, NULL);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
out = JsonbValueToJsonb(result.res);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(out);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* jsonb_object_agg aggregate function
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
jsonb_object_agg_transfn(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
MemoryContext oldcontext,
|
|
|
|
aggcontext;
|
|
|
|
JsonbInState elem;
|
2015-09-18 20:39:39 +02:00
|
|
|
JsonbAggState *state;
|
2014-12-12 21:31:14 +01:00
|
|
|
Datum val;
|
|
|
|
JsonbInState *result;
|
|
|
|
bool single_scalar;
|
|
|
|
JsonbIterator *it;
|
|
|
|
Jsonb *jbkey,
|
|
|
|
*jbval;
|
|
|
|
JsonbValue v;
|
2015-02-27 22:54:49 +01:00
|
|
|
JsonbIteratorToken type;
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
if (!AggCheckCallContext(fcinfo, &aggcontext))
|
|
|
|
{
|
|
|
|
/* cannot be called directly because of internal-type argument */
|
|
|
|
elog(ERROR, "jsonb_object_agg_transfn called in non-aggregate context");
|
|
|
|
}
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
/* set up the accumulator on the first go round */
|
2014-12-12 21:31:14 +01:00
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
if (PG_ARGISNULL(0))
|
|
|
|
{
|
2015-10-15 19:46:09 +02:00
|
|
|
Oid arg_type;
|
2014-12-12 21:31:14 +01:00
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
oldcontext = MemoryContextSwitchTo(aggcontext);
|
|
|
|
state = palloc(sizeof(JsonbAggState));
|
|
|
|
result = palloc0(sizeof(JsonbInState));
|
|
|
|
state->res = result;
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
WJB_BEGIN_OBJECT, NULL);
|
|
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
|
|
|
|
arg_type = get_fn_expr_argtype(fcinfo->flinfo, 1);
|
|
|
|
|
|
|
|
if (arg_type == InvalidOid)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("could not determine input data type")));
|
|
|
|
|
|
|
|
jsonb_categorize_type(arg_type, &state->key_category,
|
|
|
|
&state->key_output_func);
|
|
|
|
|
|
|
|
arg_type = get_fn_expr_argtype(fcinfo->flinfo, 2);
|
|
|
|
|
|
|
|
if (arg_type == InvalidOid)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("could not determine input data type")));
|
|
|
|
|
|
|
|
jsonb_categorize_type(arg_type, &state->val_category,
|
|
|
|
&state->val_output_func);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
state = (JsonbAggState *) PG_GETARG_POINTER(0);
|
|
|
|
result = state->res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* turn the argument into jsonb in the normal function context */
|
2014-12-12 21:31:14 +01:00
|
|
|
|
2015-07-24 15:40:46 +02:00
|
|
|
if (PG_ARGISNULL(1))
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("field name must not be null")));
|
|
|
|
|
|
|
|
val = PG_GETARG_DATUM(1);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
memset(&elem, 0, sizeof(JsonbInState));
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
datum_to_jsonb(val, false, &elem, state->key_category,
|
|
|
|
state->key_output_func, true);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
jbkey = JsonbValueToJsonb(elem.res);
|
|
|
|
|
|
|
|
val = PG_ARGISNULL(2) ? (Datum) 0 : PG_GETARG_DATUM(2);
|
|
|
|
|
|
|
|
memset(&elem, 0, sizeof(JsonbInState));
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
datum_to_jsonb(val, PG_ARGISNULL(2), &elem, state->val_category,
|
|
|
|
state->val_output_func, false);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
jbval = JsonbValueToJsonb(elem.res);
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
it = JsonbIteratorInit(&jbkey->root);
|
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
/* switch to the aggregate context for accumulation operations */
|
|
|
|
|
|
|
|
oldcontext = MemoryContextSwitchTo(aggcontext);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* keys should be scalar, and we should have already checked for that
|
|
|
|
* above when calling datum_to_jsonb, so we only need to look for these
|
|
|
|
* things.
|
|
|
|
*/
|
|
|
|
|
|
|
|
while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
|
|
|
|
{
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case WJB_BEGIN_ARRAY:
|
|
|
|
if (!v.val.array.rawScalar)
|
|
|
|
elog(ERROR, "unexpected structure for key");
|
|
|
|
break;
|
|
|
|
case WJB_ELEM:
|
|
|
|
if (v.type == jbvString)
|
|
|
|
{
|
2015-02-27 22:54:49 +01:00
|
|
|
/* copy string values in the aggregate context */
|
2015-03-31 14:12:27 +02:00
|
|
|
char *buf = palloc(v.val.string.len + 1);
|
2015-05-24 03:35:49 +02:00
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
snprintf(buf, v.val.string.len + 1, "%s", v.val.string.val);
|
|
|
|
v.val.string.val = buf;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("object keys must be strings")));
|
|
|
|
}
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
WJB_KEY, &v);
|
|
|
|
break;
|
|
|
|
case WJB_END_ARRAY:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
elog(ERROR, "unexpected structure for key");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
it = JsonbIteratorInit(&jbval->root);
|
|
|
|
|
|
|
|
single_scalar = false;
|
|
|
|
|
|
|
|
/*
|
2016-08-15 19:42:51 +02:00
|
|
|
* values can be anything, including structured and null, so we treat them
|
|
|
|
* as in json_agg_transfn, except that single scalars are always pushed as
|
|
|
|
* WJB_VALUE items.
|
2014-12-12 21:31:14 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
|
|
|
|
{
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case WJB_BEGIN_ARRAY:
|
|
|
|
if (v.val.array.rawScalar)
|
|
|
|
single_scalar = true;
|
|
|
|
else
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, NULL);
|
|
|
|
break;
|
|
|
|
case WJB_END_ARRAY:
|
|
|
|
if (!single_scalar)
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, NULL);
|
|
|
|
break;
|
|
|
|
case WJB_BEGIN_OBJECT:
|
|
|
|
case WJB_END_OBJECT:
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
type, NULL);
|
|
|
|
break;
|
|
|
|
case WJB_ELEM:
|
|
|
|
case WJB_KEY:
|
|
|
|
case WJB_VALUE:
|
|
|
|
if (v.type == jbvString)
|
|
|
|
{
|
2015-02-27 22:54:49 +01:00
|
|
|
/* copy string values in the aggregate context */
|
2015-03-31 14:12:27 +02:00
|
|
|
char *buf = palloc(v.val.string.len + 1);
|
2015-05-24 03:35:49 +02:00
|
|
|
|
2014-12-12 21:31:14 +01:00
|
|
|
snprintf(buf, v.val.string.len + 1, "%s", v.val.string.val);
|
|
|
|
v.val.string.val = buf;
|
|
|
|
}
|
|
|
|
else if (v.type == jbvNumeric)
|
|
|
|
{
|
|
|
|
/* same for numeric */
|
|
|
|
v.val.numeric =
|
2017-06-21 20:39:04 +02:00
|
|
|
DatumGetNumeric(DirectFunctionCall1(numeric_uplus,
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
NumericGetDatum(v.val.numeric)));
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
result->res = pushJsonbValue(&result->parseState,
|
|
|
|
single_scalar ? WJB_VALUE : type,
|
|
|
|
&v);
|
|
|
|
break;
|
2015-02-27 22:54:49 +01:00
|
|
|
default:
|
|
|
|
elog(ERROR, "unknown jsonb iterator token type");
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
PG_RETURN_POINTER(state);
|
2014-12-12 21:31:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_object_agg_finalfn(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2015-09-18 20:39:39 +02:00
|
|
|
JsonbAggState *arg;
|
2015-05-24 03:35:49 +02:00
|
|
|
JsonbInState result;
|
2014-12-12 21:31:14 +01:00
|
|
|
Jsonb *out;
|
|
|
|
|
|
|
|
/* cannot be called directly because of internal-type argument */
|
|
|
|
Assert(AggCheckCallContext(fcinfo, NULL));
|
|
|
|
|
|
|
|
if (PG_ARGISNULL(0))
|
|
|
|
PG_RETURN_NULL(); /* returns null iff no input values */
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
arg = (JsonbAggState *) PG_GETARG_POINTER(0);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
/*
|
2015-09-18 20:39:39 +02:00
|
|
|
* We need to do a shallow clone of the argument's res field in case the
|
|
|
|
* final function is called more than once, so we avoid changing the
|
2015-10-15 19:46:09 +02:00
|
|
|
* aggregate state value. A shallow clone is sufficient as we aren't
|
|
|
|
* going to change any of the values, just add the final object end
|
|
|
|
* marker.
|
2014-12-12 21:31:14 +01:00
|
|
|
*/
|
|
|
|
|
2015-09-18 20:39:39 +02:00
|
|
|
result.parseState = clone_parse_state(arg->res->parseState);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
result.res = pushJsonbValue(&result.parseState,
|
2015-05-24 03:35:49 +02:00
|
|
|
WJB_END_OBJECT, NULL);
|
2014-12-12 21:31:14 +01:00
|
|
|
|
|
|
|
out = JsonbValueToJsonb(result.res);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(out);
|
|
|
|
}
|
2018-03-29 15:33:56 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract scalar value from raw-scalar pseudo-array jsonb.
|
|
|
|
*/
|
|
|
|
static JsonbValue *
|
|
|
|
JsonbExtractScalar(JsonbContainer *jbc, JsonbValue *res)
|
|
|
|
{
|
|
|
|
JsonbIterator *it;
|
|
|
|
JsonbIteratorToken tok PG_USED_FOR_ASSERTS_ONLY;
|
|
|
|
JsonbValue tmp;
|
|
|
|
|
|
|
|
if (!JsonContainerIsArray(jbc) || !JsonContainerIsScalar(jbc))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
2018-04-26 20:47:16 +02:00
|
|
|
* A root scalar is stored as an array of one element, so we get the array
|
|
|
|
* and then its first (and only) member.
|
2018-03-29 15:33:56 +02:00
|
|
|
*/
|
|
|
|
it = JsonbIteratorInit(jbc);
|
|
|
|
|
|
|
|
tok = JsonbIteratorNext(&it, &tmp, true);
|
|
|
|
Assert(tok == WJB_BEGIN_ARRAY);
|
|
|
|
Assert(tmp.val.array.nElems == 1 && tmp.val.array.rawScalar);
|
|
|
|
|
|
|
|
tok = JsonbIteratorNext(&it, res, true);
|
2018-04-26 20:47:16 +02:00
|
|
|
Assert(tok == WJB_ELEM);
|
2018-03-29 15:33:56 +02:00
|
|
|
Assert(IsAJsonbScalar(res));
|
|
|
|
|
|
|
|
tok = JsonbIteratorNext(&it, &tmp, true);
|
2018-04-26 20:47:16 +02:00
|
|
|
Assert(tok == WJB_END_ARRAY);
|
2018-03-29 15:33:56 +02:00
|
|
|
|
|
|
|
tok = JsonbIteratorNext(&it, &tmp, true);
|
|
|
|
Assert(tok == WJB_DONE);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_bool(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
Jsonb *in = PG_GETARG_JSONB_P(0);
|
|
|
|
JsonbValue v;
|
|
|
|
|
|
|
|
if (!JsonbExtractScalar(&in->root, &v) || v.type != jbvBool)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("jsonb value must be boolean")));
|
|
|
|
|
|
|
|
PG_FREE_IF_COPY(in, 0);
|
|
|
|
|
|
|
|
PG_RETURN_BOOL(v.val.boolean);
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_numeric(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
Jsonb *in = PG_GETARG_JSONB_P(0);
|
|
|
|
JsonbValue v;
|
|
|
|
Numeric retValue;
|
|
|
|
|
|
|
|
if (!JsonbExtractScalar(&in->root, &v) || v.type != jbvNumeric)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("jsonb value must be numeric")));
|
|
|
|
|
|
|
|
/*
|
2018-04-26 20:47:16 +02:00
|
|
|
* v.val.numeric points into jsonb body, so we need to make a copy to
|
|
|
|
* return
|
2018-03-29 15:33:56 +02:00
|
|
|
*/
|
|
|
|
retValue = DatumGetNumericCopy(NumericGetDatum(v.val.numeric));
|
|
|
|
|
|
|
|
PG_FREE_IF_COPY(in, 0);
|
|
|
|
|
|
|
|
PG_RETURN_NUMERIC(retValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_int2(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
Jsonb *in = PG_GETARG_JSONB_P(0);
|
2018-04-26 20:47:16 +02:00
|
|
|
JsonbValue v;
|
2018-03-29 15:33:56 +02:00
|
|
|
Datum retValue;
|
|
|
|
|
|
|
|
if (!JsonbExtractScalar(&in->root, &v) || v.type != jbvNumeric)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("jsonb value must be numeric")));
|
|
|
|
|
|
|
|
retValue = DirectFunctionCall1(numeric_int2,
|
|
|
|
NumericGetDatum(v.val.numeric));
|
|
|
|
|
|
|
|
PG_FREE_IF_COPY(in, 0);
|
|
|
|
|
|
|
|
PG_RETURN_DATUM(retValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_int4(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
Jsonb *in = PG_GETARG_JSONB_P(0);
|
2018-04-26 20:47:16 +02:00
|
|
|
JsonbValue v;
|
2018-03-29 15:33:56 +02:00
|
|
|
Datum retValue;
|
|
|
|
|
|
|
|
if (!JsonbExtractScalar(&in->root, &v) || v.type != jbvNumeric)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("jsonb value must be numeric")));
|
|
|
|
|
|
|
|
retValue = DirectFunctionCall1(numeric_int4,
|
|
|
|
NumericGetDatum(v.val.numeric));
|
|
|
|
|
|
|
|
PG_FREE_IF_COPY(in, 0);
|
|
|
|
|
|
|
|
PG_RETURN_DATUM(retValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_int8(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
Jsonb *in = PG_GETARG_JSONB_P(0);
|
2018-04-26 20:47:16 +02:00
|
|
|
JsonbValue v;
|
2018-03-29 15:33:56 +02:00
|
|
|
Datum retValue;
|
|
|
|
|
|
|
|
if (!JsonbExtractScalar(&in->root, &v) || v.type != jbvNumeric)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("jsonb value must be numeric")));
|
|
|
|
|
|
|
|
retValue = DirectFunctionCall1(numeric_int8,
|
|
|
|
NumericGetDatum(v.val.numeric));
|
|
|
|
|
|
|
|
PG_FREE_IF_COPY(in, 0);
|
|
|
|
|
|
|
|
PG_RETURN_DATUM(retValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_float4(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
Jsonb *in = PG_GETARG_JSONB_P(0);
|
|
|
|
JsonbValue v;
|
|
|
|
Datum retValue;
|
|
|
|
|
|
|
|
if (!JsonbExtractScalar(&in->root, &v) || v.type != jbvNumeric)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("jsonb value must be numeric")));
|
|
|
|
|
|
|
|
retValue = DirectFunctionCall1(numeric_float4,
|
|
|
|
NumericGetDatum(v.val.numeric));
|
|
|
|
|
|
|
|
PG_FREE_IF_COPY(in, 0);
|
|
|
|
|
|
|
|
PG_RETURN_DATUM(retValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
jsonb_float8(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
Jsonb *in = PG_GETARG_JSONB_P(0);
|
|
|
|
JsonbValue v;
|
|
|
|
Datum retValue;
|
|
|
|
|
|
|
|
if (!JsonbExtractScalar(&in->root, &v) || v.type != jbvNumeric)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
|
|
errmsg("jsonb value must be numeric")));
|
|
|
|
|
|
|
|
retValue = DirectFunctionCall1(numeric_float8,
|
|
|
|
NumericGetDatum(v.val.numeric));
|
|
|
|
|
|
|
|
PG_FREE_IF_COPY(in, 0);
|
|
|
|
|
|
|
|
PG_RETURN_DATUM(retValue);
|
|
|
|
}
|