jsonfuncs.h File Reference

#include "common/jsonapi.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 }

Functions
JsonLexContext *	makeJsonLexContext (text *json, bool need_escapes)
bool	pg_parse_json_or_errsave (JsonLexContext *lex, JsonSemAction *sem, struct Node *escontext)
void	json_errsave_error (JsonParseErrorType error, JsonLexContext *lex, struct Node *escontext)
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)

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 46 of file jsonfuncs.h.

Typedef Documentation

JsonIterateStringValuesAction

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

Definition at line 34 of file jsonfuncs.h.

JsonToIndex

typedef enum JsonToIndex JsonToIndex

JsonTransformStringValuesAction

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

Definition at line 37 of file jsonfuncs.h.

Enumeration Type Documentation

JsonToIndex

enum JsonToIndex

Enumerator
jtiKey
jtiString
jtiNumeric
jtiBool
jtiAll

Definition at line 24 of file jsonfuncs.h.

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

Function Documentation

iterate_json_values()

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

Definition at line 5431 of file jsonfuncs.c.

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

References generate_unaccent_rules::action, iterate_values_object_field_start(), iterate_values_scalar(), makeJsonLexContext(), JsonSemAction::object_field_start, palloc0(), pg_parse_json_or_ereport, JsonSemAction::scalar, and JsonSemAction::semstate.

Referenced by json_to_tsvector_worker().

iterate_jsonb_values()

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

Definition at line 5363 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 generate_unaccent_rules::action, DatumGetCString(), DirectFunctionCall1, jbvBool, jbvNumeric, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), jtiBool, jtiKey, jtiNumeric, jtiString, numeric_out(), NumericGetDatum(), pfree(), Jsonb::root, generate_unaccent_rules::type, JsonbValue::type, JsonbValue::val, val, WJB_DONE, WJB_ELEM, WJB_KEY, and WJB_VALUE.

Referenced by jsonb_to_tsvector_worker().

json_errsave_error()

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

Definition at line 628 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, 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_typeof(), and pg_parse_json_or_errsave().

makeJsonLexContext()

JsonLexContext* makeJsonLexContext	(	text *	json,
		bool	need_escapes
	)

Definition at line 528 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(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(), each_worker(), elements_worker(), get_worker(), iterate_json_values(), json_array_length(), json_in(), json_object_keys(), json_strip_nulls(), json_typeof(), populate_recordset_worker(), and transform_json_string_values().

parse_jsonb_index_flags()

uint32 parse_jsonb_index_flags

(

Jsonb *

jb

)

Definition at line 5295 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, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), jtiAll, jtiBool, jtiKey, jtiNumeric, jtiString, pg_strncasecmp(), pnstrdup(), Jsonb::root, generate_unaccent_rules::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,
		JsonSemAction *	sem,
		struct Node *	escontext
	)

Definition at line 507 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, and pg_parse_json().

Referenced by json_in(), and jsonb_from_cstring().

transform_json_string_values()

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

Definition at line 5551 of file jsonfuncs.c.

{
    JsonLexContext *lex = makeJsonLexContext(json, true);
    JsonSemAction *sem = palloc0(sizeof(JsonSemAction));
    TransformJsonStringValuesState *state = palloc0(sizeof(TransformJsonStringValuesState));
 
    state->lex = lex;
    state->strval = makeStringInfo();
    state->action = transform_action;
    state->action_state = action_state;
 
    sem->semstate = (void *) 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);
 
    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(), makeJsonLexContext(), makeStringInfo(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc0(), pg_parse_json_or_ereport, JsonSemAction::scalar, 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
	)

Definition at line 5504 of file jsonfuncs.c.

{
    JsonbIterator *it;
    JsonbValue  v,
               *res = NULL;
    JsonbIteratorToken type;
    JsonbParseState *st = NULL;
    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);
            res = pushJsonbValue(&st, type, type < WJB_BEGIN_ARRAY ? &v : NULL);
        }
        else
        {
            res = pushJsonbValue(&st, type, (type == WJB_KEY ||
                                             type == WJB_VALUE ||
                                             type == WJB_ELEM) ? &v : NULL);
        }
    }
 
    if (res->type == jbvArray)
        res->val.array.rawScalar = is_scalar;
 
    return JsonbValueToJsonb(res);
}

References JsonbIterator::isScalar, jbvArray, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), pg_detoast_datum_packed(), pushJsonbValue(), res, Jsonb::root, generate_unaccent_rules::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().