jsonfuncs.h File Reference

#include "common/jsonapi.h"
#include "nodes/nodes.h"
#include "utils/jsonb.h"

Include dependency graph for jsonfuncs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	pg_parse_json_or_ereport(lex, sem)    (void) pg_parse_json_or_errsave(lex, sem, NULL)

Typedefs
typedef enum JsonToIndex	JsonToIndex
typedef void(*	JsonIterateStringValuesAction) (void *state, char *elem_value, int elem_len)
typedef text *(*	JsonTransformStringValuesAction) (void *state, char *elem_value, int elem_len)

Enumerations
enum	JsonToIndex {   jtiKey = 0x01 , jtiString = 0x02 , jtiNumeric = 0x04 , jtiBool = 0x08 ,   jtiAll = jtiKey | jtiString | jtiNumeric | jtiBool }
enum	JsonTypeCategory {   JSONTYPE_NULL , JSONTYPE_BOOL , JSONTYPE_NUMERIC , JSONTYPE_DATE ,   JSONTYPE_TIMESTAMP , JSONTYPE_TIMESTAMPTZ , JSONTYPE_JSON , JSONTYPE_JSONB ,   JSONTYPE_ARRAY , JSONTYPE_COMPOSITE , JSONTYPE_CAST , JSONTYPE_OTHER }

Functions
JsonLexContext *	makeJsonLexContext (JsonLexContext *lex, text *json, bool need_escapes)
bool	pg_parse_json_or_errsave (JsonLexContext *lex, const JsonSemAction *sem, struct Node *escontext)
void	json_errsave_error (JsonParseErrorType error, JsonLexContext *lex, struct Node *escontext)
JsonTokenType	json_get_first_token (text *json, bool throw_error)
uint32	parse_jsonb_index_flags (Jsonb *jb)
void	iterate_jsonb_values (Jsonb *jb, uint32 flags, void *state, JsonIterateStringValuesAction action)
void	iterate_json_values (text *json, uint32 flags, void *action_state, JsonIterateStringValuesAction action)
Jsonb *	transform_jsonb_string_values (Jsonb *jsonb, void *action_state, JsonTransformStringValuesAction transform_action)
text *	transform_json_string_values (text *json, void *action_state, JsonTransformStringValuesAction transform_action)
void	json_categorize_type (Oid typoid, bool is_jsonb, JsonTypeCategory *tcategory, Oid *outfuncoid)
void	json_check_mutability (Oid typoid, bool is_jsonb, bool *has_mutable)
Datum	datum_to_json (Datum val, JsonTypeCategory tcategory, Oid outfuncoid)
Datum	datum_to_jsonb (Datum val, JsonTypeCategory tcategory, Oid outfuncoid)
Datum	jsonb_from_text (text *js, bool unique_keys)
Datum	json_populate_type (Datum json_val, Oid json_type, Oid typid, int32 typmod, void **cache, MemoryContext mcxt, bool *isnull, bool omit_quotes, Node *escontext)

Macro Definition Documentation

pg_parse_json_or_ereport

#define pg_parse_json_or_ereport	(		lex,
			sem
	)		(void) pg_parse_json_or_errsave(lex, sem, NULL)

Definition at line 47 of file jsonfuncs.h.

{
    JSONTYPE_NULL,              /* null, so we didn't bother to identify */
    JSONTYPE_BOOL,              /* boolean (built-in types only) */
    JSONTYPE_NUMERIC,           /* numeric (ditto) */
    JSONTYPE_DATE,              /* we use special formatting for datetimes */
    JSONTYPE_TIMESTAMP,
    JSONTYPE_TIMESTAMPTZ,
    JSONTYPE_JSON,              /* JSON (and JSONB, if not is_jsonb) */
    JSONTYPE_JSONB,             /* JSONB (if is_jsonb) */
    JSONTYPE_ARRAY,             /* array */
    JSONTYPE_COMPOSITE,         /* composite */
    JSONTYPE_CAST,              /* something with an explicit cast to JSON */
    JSONTYPE_OTHER,             /* all else */
} JsonTypeCategory;
 
extern void json_categorize_type(Oid typoid, bool is_jsonb,
                                 JsonTypeCategory *tcategory, Oid *outfuncoid);
extern void json_check_mutability(Oid typoid, bool is_jsonb,
                                  bool *has_mutable);
extern Datum datum_to_json(Datum val, JsonTypeCategory tcategory,
                           Oid outfuncoid);
extern Datum datum_to_jsonb(Datum val, JsonTypeCategory tcategory,
                            Oid outfuncoid);
extern Datum jsonb_from_text(text *js, bool unique_keys);
 
extern Datum json_populate_type(Datum json_val, Oid json_type,
                                Oid typid, int32 typmod,
                                void **cache, MemoryContext mcxt,
                                bool *isnull,
                                bool omit_quotes,
                                Node *escontext);
 
#endif

Typedef Documentation

JsonIterateStringValuesAction

typedef void(* JsonIterateStringValuesAction) (void *state, char *elem_value, int elem_len)

Definition at line 35 of file jsonfuncs.h.

JsonToIndex

typedef enum JsonToIndex JsonToIndex

JsonTransformStringValuesAction

typedef text *(* JsonTransformStringValuesAction) (void *state, char *elem_value, int elem_len)

Definition at line 38 of file jsonfuncs.h.

Enumeration Type Documentation

JsonToIndex

enum JsonToIndex

Enumerator
jtiKey
jtiString
jtiNumeric
jtiBool
jtiAll

Definition at line 25 of file jsonfuncs.h.

{
    jtiKey = 0x01,
    jtiString = 0x02,
    jtiNumeric = 0x04,
    jtiBool = 0x08,
    jtiAll = jtiKey | jtiString | jtiNumeric | jtiBool
} JsonToIndex;

JsonTypeCategory

enum JsonTypeCategory

Enumerator
JSONTYPE_NULL
JSONTYPE_BOOL
JSONTYPE_NUMERIC
JSONTYPE_DATE
JSONTYPE_TIMESTAMP
JSONTYPE_TIMESTAMPTZ
JSONTYPE_JSON
JSONTYPE_JSONB
JSONTYPE_ARRAY
JSONTYPE_COMPOSITE
JSONTYPE_CAST
JSONTYPE_OTHER

Definition at line 68 of file jsonfuncs.h.

{
    JSONTYPE_NULL,              /* null, so we didn't bother to identify */
    JSONTYPE_BOOL,              /* boolean (built-in types only) */
    JSONTYPE_NUMERIC,           /* numeric (ditto) */
    JSONTYPE_DATE,              /* we use special formatting for datetimes */
    JSONTYPE_TIMESTAMP,
    JSONTYPE_TIMESTAMPTZ,
    JSONTYPE_JSON,              /* JSON (and JSONB, if not is_jsonb) */
    JSONTYPE_JSONB,             /* JSONB (if is_jsonb) */
    JSONTYPE_ARRAY,             /* array */
    JSONTYPE_COMPOSITE,         /* composite */
    JSONTYPE_CAST,              /* something with an explicit cast to JSON */
    JSONTYPE_OTHER,             /* all else */
} JsonTypeCategory;

Function Documentation

datum_to_json()

Datum datum_to_json ( Datum  val, JsonTypeCategory  tcategory, Oid  outfuncoid  )

extern

Definition at line 732 of file json.c.

{
    StringInfoData result;
 
    initStringInfo(&result);
    datum_to_json_internal(val, false, &result, tcategory, outfuncoid,
                           false);
 
    return PointerGetDatum(cstring_to_text_with_len(result.data, result.len));
}

References cstring_to_text_with_len(), StringInfoData::data, datum_to_json_internal(), fb(), initStringInfo(), StringInfoData::len, PointerGetDatum(), and val.

Referenced by ExecEvalJsonConstructor(), and to_json().

datum_to_jsonb()

Datum datum_to_jsonb ( Datum  val, JsonTypeCategory  tcategory, Oid  outfuncoid  )

extern

Definition at line 1117 of file jsonb.c.

{
    JsonbInState result;
 
    memset(&result, 0, sizeof(JsonbInState));
 
    datum_to_jsonb_internal(val, false, &result, tcategory, outfuncoid,
                            false);
 
    return JsonbPGetDatum(JsonbValueToJsonb(result.result));
}

References datum_to_jsonb_internal(), fb(), JsonbPGetDatum(), JsonbValueToJsonb(), JsonbInState::result, and val.

Referenced by ExecEvalJsonConstructor(), and to_jsonb().

iterate_json_values()

void iterate_json_values ( text *  json, uint32  flags, void *  action_state, JsonIterateStringValuesAction  action  )

extern

Definition at line 5698 of file jsonfuncs.c.

{
    JsonLexContext lex;
    JsonSemAction *sem = palloc0_object(JsonSemAction);
    IterateJsonStringValuesState *state = palloc0_object(IterateJsonStringValuesState);
 
    state->lex = makeJsonLexContext(&lex, json, true);
    state->action = action;
    state->action_state = action_state;
    state->flags = flags;
 
    sem->semstate = state;
    sem->scalar = iterate_values_scalar;
    sem->object_field_start = iterate_values_object_field_start;
 
    pg_parse_json_or_ereport(&lex, sem);
    freeJsonLexContext(&lex);
}

References freeJsonLexContext(), iterate_values_object_field_start(), iterate_values_scalar(), makeJsonLexContext(), JsonSemAction::object_field_start, palloc0_object, pg_parse_json_or_ereport, JsonSemAction::scalar, sem, and JsonSemAction::semstate.

Referenced by json_to_tsvector_worker().

iterate_jsonb_values()

void iterate_jsonb_values ( Jsonb *  jb, uint32  flags, void *  state, JsonIterateStringValuesAction  action  )

extern

Definition at line 5630 of file jsonfuncs.c.

{
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken type;
 
    it = JsonbIteratorInit(&jb->root);
 
    /*
     * Just recursively iterating over jsonb and call callback on all
     * corresponding elements
     */
    while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        if (type == WJB_KEY)
        {
            if (flags & jtiKey)
                action(state, v.val.string.val, v.val.string.len);
 
            continue;
        }
        else if (!(type == WJB_VALUE || type == WJB_ELEM))
        {
            /* do not call callback for composite JsonbValue */
            continue;
        }
 
        /* JsonbValue is a value of object or element of array */
        switch (v.type)
        {
            case jbvString:
                if (flags & jtiString)
                    action(state, v.val.string.val, v.val.string.len);
                break;
            case jbvNumeric:
                if (flags & jtiNumeric)
                {
                    char       *val;
 
                    val = DatumGetCString(DirectFunctionCall1(numeric_out,
                                                              NumericGetDatum(v.val.numeric)));
 
                    action(state, val, strlen(val));
                    pfree(val);
                }
                break;
            case jbvBool:
                if (flags & jtiBool)
                {
                    if (v.val.boolean)
                        action(state, "true", 4);
                    else
                        action(state, "false", 5);
                }
                break;
            default:
                /* do not call callback for composite JsonbValue */
                break;
        }
    }
}

References DatumGetCString(), DirectFunctionCall1, fb(), jbvBool, jbvNumeric, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), jtiBool, jtiKey, jtiNumeric, jtiString, numeric_out(), NumericGetDatum(), pfree(), type, JsonbValue::type, JsonbValue::val, val, WJB_DONE, WJB_ELEM, WJB_KEY, and WJB_VALUE.

Referenced by jsonb_to_tsvector_worker().

json_categorize_type()

void json_categorize_type ( Oid  typoid, bool  is_jsonb, JsonTypeCategory *  tcategory, Oid *  outfuncoid  )

extern

Definition at line 5967 of file jsonfuncs.c.

{
    bool        typisvarlena;
 
    /* Look through any domain */
    typoid = getBaseType(typoid);
 
    *outfuncoid = InvalidOid;
 
    switch (typoid)
    {
        case BOOLOID:
            *outfuncoid = F_BOOLOUT;
            *tcategory = JSONTYPE_BOOL;
            break;
 
        case INT2OID:
        case INT4OID:
        case INT8OID:
        case FLOAT4OID:
        case FLOAT8OID:
        case NUMERICOID:
            getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
            *tcategory = JSONTYPE_NUMERIC;
            break;
 
        case DATEOID:
            *outfuncoid = F_DATE_OUT;
            *tcategory = JSONTYPE_DATE;
            break;
 
        case TIMESTAMPOID:
            *outfuncoid = F_TIMESTAMP_OUT;
            *tcategory = JSONTYPE_TIMESTAMP;
            break;
 
        case TIMESTAMPTZOID:
            *outfuncoid = F_TIMESTAMPTZ_OUT;
            *tcategory = JSONTYPE_TIMESTAMPTZ;
            break;
 
        case JSONOID:
            getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
            *tcategory = JSONTYPE_JSON;
            break;
 
        case JSONBOID:
            getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
            *tcategory = is_jsonb ? JSONTYPE_JSONB : JSONTYPE_JSON;
            break;
 
        default:
            /* Check for arrays and composites */
            if (OidIsValid(get_element_type(typoid)) || typoid == ANYARRAYOID
                || typoid == ANYCOMPATIBLEARRAYOID || typoid == RECORDARRAYOID)
            {
                *outfuncoid = F_ARRAY_OUT;
                *tcategory = JSONTYPE_ARRAY;
            }
            else if (type_is_rowtype(typoid))   /* includes RECORDOID */
            {
                *outfuncoid = F_RECORD_OUT;
                *tcategory = JSONTYPE_COMPOSITE;
            }
            else
            {
                /*
                 * It's probably the general case.  But let's look for a cast
                 * to json (note: not to jsonb even if is_jsonb is true), if
                 * it's not built-in.
                 */
                *tcategory = JSONTYPE_OTHER;
                if (typoid >= FirstNormalObjectId)
                {
                    Oid         castfunc;
                    CoercionPathType ctype;
 
                    ctype = find_coercion_pathway(JSONOID, typoid,
                                                  COERCION_EXPLICIT,
                                                  &castfunc);
                    if (ctype == COERCION_PATH_FUNC && OidIsValid(castfunc))
                    {
                        *outfuncoid = castfunc;
                        *tcategory = JSONTYPE_CAST;
                    }
                    else
                    {
                        /* non builtin type with no cast */
                        getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
                    }
                }
                else
                {
                    /* any other builtin type */
                    getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
                }
            }
            break;
    }
}

References COERCION_EXPLICIT, COERCION_PATH_FUNC, fb(), find_coercion_pathway(), FirstNormalObjectId, get_element_type(), getBaseType(), getTypeOutputInfo(), InvalidOid, JSONTYPE_ARRAY, JSONTYPE_BOOL, JSONTYPE_CAST, JSONTYPE_COMPOSITE, JSONTYPE_DATE, JSONTYPE_JSON, JSONTYPE_JSONB, JSONTYPE_NUMERIC, JSONTYPE_OTHER, JSONTYPE_TIMESTAMP, JSONTYPE_TIMESTAMPTZ, OidIsValid, and type_is_rowtype().

Referenced by add_json(), add_jsonb(), array_to_json_internal(), array_to_jsonb_internal(), composite_to_json(), composite_to_jsonb(), ExecInitExprRec(), json_agg_transfn_worker(), json_check_mutability(), json_object_agg_transfn_worker(), jsonb_agg_transfn_worker(), jsonb_object_agg_transfn_worker(), to_json(), and to_jsonb().

json_check_mutability()

void json_check_mutability ( Oid  typoid, bool  is_jsonb, bool *  has_mutable  )

extern

Definition at line 6078 of file jsonfuncs.c.

{
    char        att_typtype = get_typtype(typoid);
    JsonTypeCategory tcategory;
    Oid         outfuncoid;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    Assert(has_mutable != NULL);
 
    if (*has_mutable)
        return;
 
    if (att_typtype == TYPTYPE_DOMAIN)
    {
        json_check_mutability(getBaseType(typoid), is_jsonb, has_mutable);
        return;
    }
    else if (att_typtype == TYPTYPE_COMPOSITE)
    {
        /*
         * For a composite type, recurse into its attributes.  Use the
         * typcache to avoid opening the relation directly.
         */
        TupleDesc   tupdesc = lookup_rowtype_tupdesc(typoid, -1);
 
        for (int i = 0; i < tupdesc->natts; i++)
        {
            Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
 
            if (attr->attisdropped)
                continue;
 
            json_check_mutability(attr->atttypid, is_jsonb, has_mutable);
            if (*has_mutable)
                break;
        }
        ReleaseTupleDesc(tupdesc);
        return;
    }
    else if (att_typtype == TYPTYPE_RANGE)
    {
        json_check_mutability(get_range_subtype(typoid), is_jsonb,
                              has_mutable);
        return;
    }
    else if (att_typtype == TYPTYPE_MULTIRANGE)
    {
        json_check_mutability(get_multirange_range(typoid), is_jsonb,
                              has_mutable);
        return;
    }
    else
    {
        Oid         att_typelem = get_element_type(typoid);
 
        if (OidIsValid(att_typelem))
        {
            /* recurse into array element type */
            json_check_mutability(att_typelem, is_jsonb, has_mutable);
            return;
        }
    }
 
    json_categorize_type(typoid, is_jsonb, &tcategory, &outfuncoid);
 
    switch (tcategory)
    {
        case JSONTYPE_NULL:
        case JSONTYPE_BOOL:
        case JSONTYPE_NUMERIC:
            break;
 
        case JSONTYPE_DATE:
        case JSONTYPE_TIMESTAMP:
        case JSONTYPE_TIMESTAMPTZ:
            *has_mutable = true;
            break;
 
        case JSONTYPE_JSON:
        case JSONTYPE_JSONB:
        case JSONTYPE_ARRAY:
        case JSONTYPE_COMPOSITE:
            break;
 
        case JSONTYPE_CAST:
        case JSONTYPE_OTHER:
            if (func_volatile(outfuncoid) != PROVOLATILE_IMMUTABLE)
                *has_mutable = true;
            break;
    }
}

References Assert, check_stack_depth(), fb(), func_volatile(), get_element_type(), get_multirange_range(), get_range_subtype(), get_typtype(), getBaseType(), i, json_categorize_type(), json_check_mutability(), JSONTYPE_ARRAY, JSONTYPE_BOOL, JSONTYPE_CAST, JSONTYPE_COMPOSITE, JSONTYPE_DATE, JSONTYPE_JSON, JSONTYPE_JSONB, JSONTYPE_NULL, JSONTYPE_NUMERIC, JSONTYPE_OTHER, JSONTYPE_TIMESTAMP, JSONTYPE_TIMESTAMPTZ, lookup_rowtype_tupdesc(), TupleDescData::natts, OidIsValid, ReleaseTupleDesc, and TupleDescAttr().

Referenced by json_check_mutability(), to_json_is_immutable(), and to_jsonb_is_immutable().

json_errsave_error()

void json_errsave_error ( JsonParseErrorType  error, JsonLexContext *  lex, struct Node *  escontext  )

extern

Definition at line 644 of file jsonfuncs.c.

{
    if (error == JSON_UNICODE_HIGH_ESCAPE ||
        error == JSON_UNICODE_UNTRANSLATABLE ||
        error == JSON_UNICODE_CODE_POINT_ZERO)
        errsave(escontext,
                (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
                 errmsg("unsupported Unicode escape sequence"),
                 errdetail_internal("%s", json_errdetail(error, lex)),
                 report_json_context(lex)));
    else if (error == JSON_SEM_ACTION_FAILED)
    {
        /* semantic action function had better have reported something */
        if (!SOFT_ERROR_OCCURRED(escontext))
            elog(ERROR, "JSON semantic action function did not provide error information");
    }
    else
        errsave(escontext,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s", "json"),
                 errdetail_internal("%s", json_errdetail(error, lex)),
                 report_json_context(lex)));
}

References elog, errcode(), errdetail_internal(), errmsg, ERROR, error(), errsave, fb(), json_errdetail(), JSON_SEM_ACTION_FAILED, JSON_UNICODE_CODE_POINT_ZERO, JSON_UNICODE_HIGH_ESCAPE, JSON_UNICODE_UNTRANSLATABLE, report_json_context(), and SOFT_ERROR_OCCURRED.

Referenced by get_array_start(), json_get_first_token(), json_typeof(), json_validate(), and pg_parse_json_or_errsave().

json_get_first_token()

JsonTokenType json_get_first_token ( text *  json, bool  throw_error  )

extern

Definition at line 5940 of file jsonfuncs.c.

{
    JsonLexContext lex;
    JsonParseErrorType result;
 
    makeJsonLexContext(&lex, json, false);
 
    /* Lex exactly one token from the input and check its type. */
    result = json_lex(&lex);
 
    if (result == JSON_SUCCESS)
        return lex.token_type;
 
    if (throw_error)
        json_errsave_error(result, &lex, NULL);
 
    return JSON_TOKEN_INVALID;  /* invalid json */
}

References fb(), json_errsave_error(), json_lex(), JSON_SUCCESS, JSON_TOKEN_INVALID, makeJsonLexContext(), and JsonLexContext::token_type.

Referenced by ExecEvalJsonIsPredicate().

json_populate_type()

Datum json_populate_type ( Datum  json_val, Oid  json_type, Oid  typid, int32  typmod, void **  cache, MemoryContext  mcxt, bool *  isnull, bool  omit_quotes, Node *  escontext  )

extern

Definition at line 3345 of file jsonfuncs.c.

{
    JsValue     jsv = {0};
    JsonbValue  jbv;
 
    jsv.is_json = json_type == JSONOID;
 
    if (*isnull)
    {
        if (jsv.is_json)
            jsv.val.json.str = NULL;
        else
            jsv.val.jsonb = NULL;
    }
    else if (jsv.is_json)
    {
        text       *json = DatumGetTextPP(json_val);
 
        jsv.val.json.str = VARDATA_ANY(json);
        jsv.val.json.len = VARSIZE_ANY_EXHDR(json);
        jsv.val.json.type = JSON_TOKEN_INVALID; /* not used in
                                                 * populate_composite() */
    }
    else
    {
        Jsonb      *jsonb = DatumGetJsonbP(json_val);
 
        jsv.val.jsonb = &jbv;
 
        if (omit_quotes)
        {
            char       *str = JsonbUnquote(DatumGetJsonbP(json_val));
 
            /* fill the quote-stripped string */
            jbv.type = jbvString;
            jbv.val.string.len = strlen(str);
            jbv.val.string.val = str;
        }
        else
        {
            /* fill binary jsonb value pointing to jb */
            jbv.type = jbvBinary;
            jbv.val.binary.data = &jsonb->root;
            jbv.val.binary.len = VARSIZE(jsonb) - VARHDRSZ;
        }
    }
 
    if (*cache == NULL)
        *cache = MemoryContextAllocZero(mcxt, sizeof(ColumnIOData));
 
    return populate_record_field(*cache, typid, typmod, NULL, mcxt,
                                 PointerGetDatum(NULL), &jsv, isnull,
                                 escontext, omit_quotes);
}

References DatumGetJsonbP(), DatumGetTextPP, fb(), jbvBinary, jbvString, JSON_TOKEN_INVALID, JsonbUnquote(), MemoryContextAllocZero(), PointerGetDatum(), populate_record_field(), Jsonb::root, str, JsonbValue::val, VARDATA_ANY(), VARHDRSZ, VARSIZE(), and VARSIZE_ANY_EXHDR().

Referenced by ExecEvalJsonCoercion().

jsonb_from_text()

Datum jsonb_from_text ( text *  js, bool  unique_keys  )

extern

Definition at line 139 of file jsonb.c.

{
    return jsonb_from_cstring(VARDATA_ANY(js),
                              VARSIZE_ANY_EXHDR(js),
                              unique_keys,
                              NULL);
}

References fb(), jsonb_from_cstring(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by ExecEvalJsonConstructor().

makeJsonLexContext()

JsonLexContext * makeJsonLexContext ( JsonLexContext *  lex, text *  json, bool  need_escapes  )

extern

Definition at line 543 of file jsonfuncs.c.

{
    /*
     * Most callers pass a detoasted datum, but it's not clear that they all
     * do.  pg_detoast_datum_packed() is cheap insurance.
     */
    json = pg_detoast_datum_packed(json);
 
    return makeJsonLexContextCstringLen(lex,
                                        VARDATA_ANY(json),
                                        VARSIZE_ANY_EXHDR(json),
                                        GetDatabaseEncoding(),
                                        need_escapes);
}

References GetDatabaseEncoding(), makeJsonLexContextCstringLen(), pg_detoast_datum_packed(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by datum_to_jsonb_internal(), each_worker(), elements_worker(), get_worker(), iterate_json_values(), json_array_length(), json_get_first_token(), json_in(), json_object_keys(), json_strip_nulls(), json_typeof(), json_validate(), populate_recordset_worker(), and transform_json_string_values().

parse_jsonb_index_flags()

uint32 parse_jsonb_index_flags ( Jsonb *  jb )

extern

Definition at line 5562 of file jsonfuncs.c.

{
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken type;
    uint32      flags = 0;
 
    it = JsonbIteratorInit(&jb->root);
 
    type = JsonbIteratorNext(&it, &v, false);
 
    /*
     * We iterate over array (scalar internally is represented as array, so,
     * we will accept it too) to check all its elements.  Flag names are
     * chosen the same as jsonb_typeof uses.
     */
    if (type != WJB_BEGIN_ARRAY)
        ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                        errmsg("wrong flag type, only arrays and scalars are allowed")));
 
    while ((type = JsonbIteratorNext(&it, &v, false)) == WJB_ELEM)
    {
        if (v.type != jbvString)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("flag array element is not a string"),
                     errhint("Possible values are: \"string\", \"numeric\", \"boolean\", \"key\", and \"all\".")));
 
        if (v.val.string.len == 3 &&
            pg_strncasecmp(v.val.string.val, "all", 3) == 0)
            flags |= jtiAll;
        else if (v.val.string.len == 3 &&
                 pg_strncasecmp(v.val.string.val, "key", 3) == 0)
            flags |= jtiKey;
        else if (v.val.string.len == 6 &&
                 pg_strncasecmp(v.val.string.val, "string", 6) == 0)
            flags |= jtiString;
        else if (v.val.string.len == 7 &&
                 pg_strncasecmp(v.val.string.val, "numeric", 7) == 0)
            flags |= jtiNumeric;
        else if (v.val.string.len == 7 &&
                 pg_strncasecmp(v.val.string.val, "boolean", 7) == 0)
            flags |= jtiBool;
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("wrong flag in flag array: \"%s\"",
                            pnstrdup(v.val.string.val, v.val.string.len)),
                     errhint("Possible values are: \"string\", \"numeric\", \"boolean\", \"key\", and \"all\".")));
    }
 
    /* expect end of array now */
    if (type != WJB_END_ARRAY)
        elog(ERROR, "unexpected end of flag array");
 
    /* get final WJB_DONE and free iterator */
    type = JsonbIteratorNext(&it, &v, false);
    if (type != WJB_DONE)
        elog(ERROR, "unexpected end of flag array");
 
    return flags;
}

References elog, ereport, errcode(), errhint(), errmsg, ERROR, fb(), jbvString, JsonbIteratorInit(), JsonbIteratorNext(), jtiAll, jtiBool, jtiKey, jtiNumeric, jtiString, pg_strncasecmp(), pnstrdup(), type, JsonbValue::type, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, and WJB_END_ARRAY.

Referenced by json_to_tsvector(), json_to_tsvector_byid(), jsonb_to_tsvector(), and jsonb_to_tsvector_byid().

pg_parse_json_or_errsave()

bool pg_parse_json_or_errsave ( JsonLexContext *  lex, const JsonSemAction *  sem, struct Node *  escontext  )

extern

Definition at line 522 of file jsonfuncs.c.

{
    JsonParseErrorType result;
 
    result = pg_parse_json(lex, sem);
    if (result != JSON_SUCCESS)
    {
        json_errsave_error(result, lex, escontext);
        return false;
    }
    return true;
}

References json_errsave_error(), JSON_SUCCESS, pg_parse_json(), and sem.

Referenced by get_json_object_as_hash(), json_in(), jsonb_from_cstring(), and populate_array_json().

transform_json_string_values()

text * transform_json_string_values ( text *  json, void *  action_state, JsonTransformStringValuesAction  transform_action  )

extern

Definition at line 5818 of file jsonfuncs.c.

{
    JsonLexContext lex;
    JsonSemAction *sem = palloc0_object(JsonSemAction);
    TransformJsonStringValuesState *state = palloc0_object(TransformJsonStringValuesState);
    StringInfoData strbuf;
 
    initStringInfo(&strbuf);
 
    state->lex = makeJsonLexContext(&lex, json, true);
    state->strval = &strbuf;
    state->action = transform_action;
    state->action_state = action_state;
 
    sem->semstate = state;
    sem->object_start = transform_string_values_object_start;
    sem->object_end = transform_string_values_object_end;
    sem->array_start = transform_string_values_array_start;
    sem->array_end = transform_string_values_array_end;
    sem->scalar = transform_string_values_scalar;
    sem->array_element_start = transform_string_values_array_element_start;
    sem->object_field_start = transform_string_values_object_field_start;
 
    pg_parse_json_or_ereport(&lex, sem);
    freeJsonLexContext(&lex);
 
    return cstring_to_text_with_len(state->strval->data, state->strval->len);
}

References JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, cstring_to_text_with_len(), fb(), freeJsonLexContext(), initStringInfo(), makeJsonLexContext(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc0_object, pg_parse_json_or_ereport, JsonSemAction::scalar, sem, JsonSemAction::semstate, transform_string_values_array_element_start(), transform_string_values_array_end(), transform_string_values_array_start(), transform_string_values_object_end(), transform_string_values_object_field_start(), transform_string_values_object_start(), and transform_string_values_scalar().

Referenced by ts_headline_json_byid_opt().

transform_jsonb_string_values()

Jsonb * transform_jsonb_string_values ( Jsonb *  jsonb, void *  action_state, JsonTransformStringValuesAction  transform_action  )

extern

Definition at line 5772 of file jsonfuncs.c.

{
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken type;
    JsonbInState st = {0};
    text       *out;
    bool        is_scalar = false;
 
    it = JsonbIteratorInit(&jsonb->root);
    is_scalar = it->isScalar;
 
    while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        if ((type == WJB_VALUE || type == WJB_ELEM) && v.type == jbvString)
        {
            out = transform_action(action_state, v.val.string.val, v.val.string.len);
            /* out is probably not toasted, but let's be sure */
            out = pg_detoast_datum_packed(out);
            v.val.string.val = VARDATA_ANY(out);
            v.val.string.len = VARSIZE_ANY_EXHDR(out);
            pushJsonbValue(&st, type, type < WJB_BEGIN_ARRAY ? &v : NULL);
        }
        else
        {
            pushJsonbValue(&st, type, (type == WJB_KEY ||
                                       type == WJB_VALUE ||
                                       type == WJB_ELEM) ? &v : NULL);
        }
    }
 
    if (st.result->type == jbvArray)
        st.result->val.array.rawScalar = is_scalar;
 
    return JsonbValueToJsonb(st.result);
}

References fb(), jbvArray, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), pg_detoast_datum_packed(), pushJsonbValue(), JsonbInState::result, Jsonb::root, type, JsonbValue::type, JsonbValue::val, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, WJB_KEY, and WJB_VALUE.

Referenced by ts_headline_jsonb_byid_opt().