jsonfuncs.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/htup_details.h"
#include "catalog/pg_type.h"
#include "fmgr.h"
#include "funcapi.h"
#include "lib/stringinfo.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/hsearch.h"
#include "utils/json.h"
#include "utils/jsonapi.h"
#include "utils/jsonb.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for jsonfuncs.c:

Go to the source code of this file.

Data Structures
struct	OkeysState
struct	IterateJsonStringValuesState
struct	TransformJsonStringValuesState
struct	GetState
struct	AlenState
struct	EachState
struct	ElementsState
struct	JHashState
struct	JsonHashEntry
struct	ScalarIOData
struct	ArrayIOData
struct	CompositeIOData
struct	DomainIOData
struct	ColumnIOData
struct	RecordIOData
struct	PopulateRecordsetCache
struct	PopulateRecordsetState
struct	PopulateRecordCache
struct	PopulateArrayContext
struct	PopulateArrayState
struct	StripnullState
struct	JsValue
struct	JsObject

Macros
#define	JB_PATH_CREATE   0x0001
#define	JB_PATH_DELETE   0x0002
#define	JB_PATH_REPLACE   0x0004
#define	JB_PATH_INSERT_BEFORE   0x0008
#define	JB_PATH_INSERT_AFTER   0x0010
#define	JB_PATH_CREATE_OR_INSERT   (JB_PATH_INSERT_BEFORE | JB_PATH_INSERT_AFTER | JB_PATH_CREATE)
#define	JsValueIsNull(jsv)
#define	JsValueIsString(jsv)
#define	JsObjectIsEmpty(jso)
#define	JsObjectFree(jso)

Typedefs
typedef struct OkeysState	OkeysState
typedef struct IterateJsonStringValuesState	IterateJsonStringValuesState
typedef struct TransformJsonStringValuesState	TransformJsonStringValuesState
typedef struct GetState	GetState
typedef struct AlenState	AlenState
typedef struct EachState	EachState
typedef struct ElementsState	ElementsState
typedef struct JHashState	JHashState
typedef struct JsonHashEntry	JsonHashEntry
typedef struct ScalarIOData	ScalarIOData
typedef struct ColumnIOData	ColumnIOData
typedef struct RecordIOData	RecordIOData
typedef struct ArrayIOData	ArrayIOData
typedef struct CompositeIOData	CompositeIOData
typedef struct DomainIOData	DomainIOData
typedef enum TypeCat	TypeCat
typedef struct PopulateRecordsetCache	PopulateRecordsetCache
typedef struct PopulateRecordsetState	PopulateRecordsetState
typedef struct PopulateRecordCache	PopulateRecordCache
typedef struct PopulateArrayContext	PopulateArrayContext
typedef struct PopulateArrayState	PopulateArrayState
typedef struct StripnullState	StripnullState
typedef struct JsValue	JsValue
typedef struct JsObject	JsObject

Enumerations
enum	TypeCat {   TYPECAT_SCALAR = 's', TYPECAT_ARRAY = 'a', TYPECAT_COMPOSITE = 'c', TYPECAT_COMPOSITE_DOMAIN = 'C',   TYPECAT_DOMAIN = 'd' }

Functions
static void	okeys_object_field_start (void *state, char *fname, bool isnull)
static void	okeys_array_start (void *state)
static void	okeys_scalar (void *state, char *token, JsonTokenType tokentype)
static void	get_object_start (void *state)
static void	get_object_end (void *state)
static void	get_object_field_start (void *state, char *fname, bool isnull)
static void	get_object_field_end (void *state, char *fname, bool isnull)
static void	get_array_start (void *state)
static void	get_array_end (void *state)
static void	get_array_element_start (void *state, bool isnull)
static void	get_array_element_end (void *state, bool isnull)
static void	get_scalar (void *state, char *token, JsonTokenType tokentype)
static Datum	get_path_all (FunctionCallInfo fcinfo, bool as_text)
static text *	get_worker (text *json, char **tpath, int *ipath, int npath, bool normalize_results)
static Datum	get_jsonb_path_all (FunctionCallInfo fcinfo, bool as_text)
static void	alen_object_start (void *state)
static void	alen_scalar (void *state, char *token, JsonTokenType tokentype)
static void	alen_array_element_start (void *state, bool isnull)
static Datum	each_worker (FunctionCallInfo fcinfo, bool as_text)
static Datum	each_worker_jsonb (FunctionCallInfo fcinfo, const char *funcname, bool as_text)
static void	each_object_field_start (void *state, char *fname, bool isnull)
static void	each_object_field_end (void *state, char *fname, bool isnull)
static void	each_array_start (void *state)
static void	each_scalar (void *state, char *token, JsonTokenType tokentype)
static Datum	elements_worker (FunctionCallInfo fcinfo, const char *funcname, bool as_text)
static Datum	elements_worker_jsonb (FunctionCallInfo fcinfo, const char *funcname, bool as_text)
static void	elements_object_start (void *state)
static void	elements_array_element_start (void *state, bool isnull)
static void	elements_array_element_end (void *state, bool isnull)
static void	elements_scalar (void *state, char *token, JsonTokenType tokentype)
static HTAB *	get_json_object_as_hash (char *json, int len, const char *funcname)
static void	populate_array_object_start (void *_state)
static void	populate_array_array_end (void *_state)
static void	populate_array_element_start (void *_state, bool isnull)
static void	populate_array_element_end (void *_state, bool isnull)
static void	populate_array_scalar (void *_state, char *token, JsonTokenType tokentype)
static void	hash_object_field_start (void *state, char *fname, bool isnull)
static void	hash_object_field_end (void *state, char *fname, bool isnull)
static void	hash_array_start (void *state)
static void	hash_scalar (void *state, char *token, JsonTokenType tokentype)
static void	populate_recordset_object_field_start (void *state, char *fname, bool isnull)
static void	populate_recordset_object_field_end (void *state, char *fname, bool isnull)
static void	populate_recordset_scalar (void *state, char *token, JsonTokenType tokentype)
static void	populate_recordset_object_start (void *state)
static void	populate_recordset_object_end (void *state)
static void	populate_recordset_array_start (void *state)
static void	populate_recordset_array_element_start (void *state, bool isnull)
static void	sn_object_start (void *state)
static void	sn_object_end (void *state)
static void	sn_array_start (void *state)
static void	sn_array_end (void *state)
static void	sn_object_field_start (void *state, char *fname, bool isnull)
static void	sn_array_element_start (void *state, bool isnull)
static void	sn_scalar (void *state, char *token, JsonTokenType tokentype)
static Datum	populate_recordset_worker (FunctionCallInfo fcinfo, const char *funcname, bool have_record_arg)
static Datum	populate_record_worker (FunctionCallInfo fcinfo, const char *funcname, bool have_record_arg)
static HeapTupleHeader	populate_record (TupleDesc tupdesc, RecordIOData **record_p, HeapTupleHeader defaultval, MemoryContext mcxt, JsObject *obj)
static void	JsValueToJsObject (JsValue *jsv, JsObject *jso)
static Datum	populate_composite (CompositeIOData *io, Oid typid, const char *colname, MemoryContext mcxt, HeapTupleHeader defaultval, JsValue *jsv, bool isnull)
static Datum	populate_scalar (ScalarIOData *io, Oid typid, int32 typmod, JsValue *jsv)
static void	prepare_column_cache (ColumnIOData *column, Oid typid, int32 typmod, MemoryContext mcxt, bool need_scalar)
static Datum	populate_record_field (ColumnIOData *col, Oid typid, int32 typmod, const char *colname, MemoryContext mcxt, Datum defaultval, JsValue *jsv, bool *isnull)
static RecordIOData *	allocate_record_info (MemoryContext mcxt, int ncolumns)
static bool	JsObjectGetField (JsObject *obj, char *field, JsValue *jsv)
static void	populate_recordset_record (PopulateRecordsetState *state, JsObject *obj)
static void	populate_array_json (PopulateArrayContext *ctx, char *json, int len)
static void	populate_array_dim_jsonb (PopulateArrayContext *ctx, JsonbValue *jbv, int ndim)
static void	populate_array_report_expected_array (PopulateArrayContext *ctx, int ndim)
static void	populate_array_assign_ndims (PopulateArrayContext *ctx, int ndims)
static void	populate_array_check_dimension (PopulateArrayContext *ctx, int ndim)
static void	populate_array_element (PopulateArrayContext *ctx, int ndim, JsValue *jsv)
static Datum	populate_array (ArrayIOData *aio, const char *colname, MemoryContext mcxt, JsValue *jsv)
static Datum	populate_domain (DomainIOData *io, Oid typid, const char *colname, MemoryContext mcxt, JsValue *jsv, bool isnull)
static JsonbValue *	findJsonbValueFromContainerLen (JsonbContainer *container, uint32 flags, char *key, uint32 keylen)
static JsonbValue *	IteratorConcat (JsonbIterator **it1, JsonbIterator **it2, JsonbParseState **state)
static JsonbValue *	setPath (JsonbIterator **it, Datum *path_elems, bool *path_nulls, int path_len, JsonbParseState **st, int level, Jsonb *newval, int op_type)
static void	setPathObject (JsonbIterator **it, Datum *path_elems, bool *path_nulls, int path_len, JsonbParseState **st, int level, Jsonb *newval, uint32 npairs, int op_type)
static void	setPathArray (JsonbIterator **it, Datum *path_elems, bool *path_nulls, int path_len, JsonbParseState **st, int level, Jsonb *newval, uint32 nelems, int op_type)
static void	addJsonbToParseState (JsonbParseState **jbps, Jsonb *jb)
static void	iterate_values_scalar (void *state, char *token, JsonTokenType tokentype)
static void	iterate_values_object_field_start (void *state, char *fname, bool isnull)
static void	transform_string_values_object_start (void *state)
static void	transform_string_values_object_end (void *state)
static void	transform_string_values_array_start (void *state)
static void	transform_string_values_array_end (void *state)
static void	transform_string_values_object_field_start (void *state, char *fname, bool isnull)
static void	transform_string_values_array_element_start (void *state, bool isnull)
static void	transform_string_values_scalar (void *state, char *token, JsonTokenType tokentype)
Datum	jsonb_object_keys (PG_FUNCTION_ARGS)
Datum	json_object_keys (PG_FUNCTION_ARGS)
Datum	json_object_field (PG_FUNCTION_ARGS)
Datum	jsonb_object_field (PG_FUNCTION_ARGS)
Datum	json_object_field_text (PG_FUNCTION_ARGS)
Datum	jsonb_object_field_text (PG_FUNCTION_ARGS)
Datum	json_array_element (PG_FUNCTION_ARGS)
Datum	jsonb_array_element (PG_FUNCTION_ARGS)
Datum	json_array_element_text (PG_FUNCTION_ARGS)
Datum	jsonb_array_element_text (PG_FUNCTION_ARGS)
Datum	json_extract_path (PG_FUNCTION_ARGS)
Datum	json_extract_path_text (PG_FUNCTION_ARGS)
Datum	jsonb_extract_path (PG_FUNCTION_ARGS)
Datum	jsonb_extract_path_text (PG_FUNCTION_ARGS)
Datum	json_array_length (PG_FUNCTION_ARGS)
Datum	jsonb_array_length (PG_FUNCTION_ARGS)
Datum	json_each (PG_FUNCTION_ARGS)
Datum	jsonb_each (PG_FUNCTION_ARGS)
Datum	json_each_text (PG_FUNCTION_ARGS)
Datum	jsonb_each_text (PG_FUNCTION_ARGS)
Datum	jsonb_array_elements (PG_FUNCTION_ARGS)
Datum	jsonb_array_elements_text (PG_FUNCTION_ARGS)
Datum	json_array_elements (PG_FUNCTION_ARGS)
Datum	json_array_elements_text (PG_FUNCTION_ARGS)
Datum	jsonb_populate_record (PG_FUNCTION_ARGS)
Datum	jsonb_to_record (PG_FUNCTION_ARGS)
Datum	json_populate_record (PG_FUNCTION_ARGS)
Datum	json_to_record (PG_FUNCTION_ARGS)
static void	update_cached_tupdesc (CompositeIOData *io, MemoryContext mcxt)
Datum	jsonb_populate_recordset (PG_FUNCTION_ARGS)
Datum	jsonb_to_recordset (PG_FUNCTION_ARGS)
Datum	json_populate_recordset (PG_FUNCTION_ARGS)
Datum	json_to_recordset (PG_FUNCTION_ARGS)
Datum	json_strip_nulls (PG_FUNCTION_ARGS)
Datum	jsonb_strip_nulls (PG_FUNCTION_ARGS)
Datum	jsonb_pretty (PG_FUNCTION_ARGS)
Datum	jsonb_concat (PG_FUNCTION_ARGS)
Datum	jsonb_delete (PG_FUNCTION_ARGS)
Datum	jsonb_delete_array (PG_FUNCTION_ARGS)
Datum	jsonb_delete_idx (PG_FUNCTION_ARGS)
Datum	jsonb_set (PG_FUNCTION_ARGS)
Datum	jsonb_delete_path (PG_FUNCTION_ARGS)
Datum	jsonb_insert (PG_FUNCTION_ARGS)
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

JB_PATH_CREATE

#define JB_PATH_CREATE   0x0001

Definition at line 38 of file jsonfuncs.c.

Referenced by jsonb_set(), and setPathArray().

JB_PATH_CREATE_OR_INSERT

#define JB_PATH_CREATE_OR_INSERT   (JB_PATH_INSERT_BEFORE | JB_PATH_INSERT_AFTER | JB_PATH_CREATE)

Definition at line 43 of file jsonfuncs.c.

Referenced by setPathArray(), and setPathObject().

JB_PATH_DELETE

#define JB_PATH_DELETE   0x0002

Definition at line 39 of file jsonfuncs.c.

Referenced by jsonb_delete_path(), and setPathObject().

JB_PATH_INSERT_AFTER

#define JB_PATH_INSERT_AFTER   0x0010

Definition at line 42 of file jsonfuncs.c.

Referenced by jsonb_insert(), setPathArray(), and setPathObject().

JB_PATH_INSERT_BEFORE

#define JB_PATH_INSERT_BEFORE   0x0008

Definition at line 41 of file jsonfuncs.c.

Referenced by jsonb_insert(), setPathArray(), and setPathObject().

JB_PATH_REPLACE

#define JB_PATH_REPLACE   0x0004

Definition at line 40 of file jsonfuncs.c.

Referenced by jsonb_set(), and setPathArray().

JsObjectFree

#define JsObjectFree

(

jso

)

Value:

do { \
        if ((jso)->is_json) \
            hash_destroy((jso)->val.json_hash); \
    } while (0)

Definition at line 332 of file jsonfuncs.c.

Referenced by populate_composite().

JsObjectIsEmpty

#define JsObjectIsEmpty

(

jso

)

Value:

((jso)->is_json \
        ? hash_get_num_entries((jso)->val.json_hash) == 0 \
        : ((jso)->val.jsonb_cont == NULL || \
           JsonContainerSize((jso)->val.jsonb_cont) == 0))

Definition at line 326 of file jsonfuncs.c.

Referenced by populate_record().

JsValueIsNull

#define JsValueIsNull

(

jsv

)

Value:

((jsv)->is_json ?  \
        (!(jsv)->val.json.str || (jsv)->val.json.type == JSON_TOKEN_NULL) : \
        (!(jsv)->val.jsonb || (jsv)->val.jsonb->type == jbvNull))

Definition at line 317 of file jsonfuncs.c.

Referenced by populate_record_field().

JsValueIsString

#define JsValueIsString

(

jsv

)

Value:

((jsv)->is_json ? (jsv)->val.json.type == JSON_TOKEN_STRING \
        : ((jsv)->val.jsonb && (jsv)->val.jsonb->type == jbvString))

Definition at line 322 of file jsonfuncs.c.

Referenced by populate_record_field().

Typedef Documentation

AlenState

typedef struct AlenState AlenState

ArrayIOData

typedef struct ArrayIOData ArrayIOData

ColumnIOData

typedef struct ColumnIOData ColumnIOData

Definition at line 154 of file jsonfuncs.c.

CompositeIOData

typedef struct CompositeIOData CompositeIOData

DomainIOData

typedef struct DomainIOData DomainIOData

EachState

typedef struct EachState EachState

ElementsState

typedef struct ElementsState ElementsState

GetState

typedef struct GetState GetState

IterateJsonStringValuesState

typedef struct IterateJsonStringValuesState IterateJsonStringValuesState

JHashState

typedef struct JHashState JHashState

JsObject

typedef struct JsObject JsObject

JsonHashEntry

typedef struct JsonHashEntry JsonHashEntry

JsValue

typedef struct JsValue JsValue

OkeysState

typedef struct OkeysState OkeysState

PopulateArrayContext

typedef struct PopulateArrayContext PopulateArrayContext

PopulateArrayState

typedef struct PopulateArrayState PopulateArrayState

PopulateRecordCache

typedef struct PopulateRecordCache PopulateRecordCache

PopulateRecordsetCache

typedef struct PopulateRecordsetCache PopulateRecordsetCache

PopulateRecordsetState

typedef struct PopulateRecordsetState PopulateRecordsetState

RecordIOData

typedef struct RecordIOData RecordIOData

Definition at line 155 of file jsonfuncs.c.

ScalarIOData

typedef struct ScalarIOData ScalarIOData

StripnullState

typedef struct StripnullState StripnullState

TransformJsonStringValuesState

typedef struct TransformJsonStringValuesState TransformJsonStringValuesState

TypeCat

typedef enum TypeCat TypeCat

Enumeration Type Documentation

TypeCat

enum TypeCat

Enumerator
TYPECAT_SCALAR
TYPECAT_ARRAY
TYPECAT_COMPOSITE
TYPECAT_COMPOSITE_DOMAIN
TYPECAT_DOMAIN

Definition at line 191 of file jsonfuncs.c.

{
    TYPECAT_SCALAR = 's',
    TYPECAT_ARRAY = 'a',
    TYPECAT_COMPOSITE = 'c',
    TYPECAT_COMPOSITE_DOMAIN = 'C',
    TYPECAT_DOMAIN = 'd'
} TypeCat;

Function Documentation

addJsonbToParseState()

static void addJsonbToParseState ( JsonbParseState **  jbps, Jsonb *  jb  )

static

Definition at line 4102 of file jsonfuncs.c.

References Assert, elog, ERROR, JB_ROOT_IS_SCALAR, jbvArray, jbvObject, JsonbIteratorInit(), JsonbIteratorNext(), pushJsonbValue(), Jsonb::root, generate_unaccent_rules::type, JsonbValue::type, WJB_DONE, WJB_ELEM, WJB_KEY, and WJB_VALUE.

Referenced by setPathArray(), and setPathObject().

{
    JsonbIterator *it;
    JsonbValue *o = &(*jbps)->contVal;
    JsonbValue  v;
    JsonbIteratorToken type;

    it = JsonbIteratorInit(&jb->root);

    Assert(o->type == jbvArray || o->type == jbvObject);

    if (JB_ROOT_IS_SCALAR(jb))
    {
        (void) JsonbIteratorNext(&it, &v, false);   /* skip array header */
        Assert(v.type == jbvArray);
        (void) JsonbIteratorNext(&it, &v, false);   /* fetch scalar value */

        switch (o->type)
        {
            case jbvArray:
                (void) pushJsonbValue(jbps, WJB_ELEM, &v);
                break;
            case jbvObject:
                (void) pushJsonbValue(jbps, WJB_VALUE, &v);
                break;
            default:
                elog(ERROR, "unexpected parent of nested structure");
        }
    }
    else
    {
        while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
        {
            if (type == WJB_KEY || type == WJB_VALUE || type == WJB_ELEM)
                (void) pushJsonbValue(jbps, type, &v);
            else
                (void) pushJsonbValue(jbps, type, NULL);
        }
    }

}

alen_array_element_start()

static void alen_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 1630 of file jsonfuncs.c.

References AlenState::count, AlenState::lex, and JsonLexContext::lex_level.

Referenced by json_array_length().

{
    AlenState  *_state = (AlenState *) state;

    /* just count up all the level 1 elements */
    if (_state->lex->lex_level == 1)
        _state->count++;
}

alen_object_start()

static void alen_object_start ( void *  state )

static

Definition at line 1606 of file jsonfuncs.c.

References ereport, errcode(), errmsg(), ERROR, AlenState::lex, and JsonLexContext::lex_level.

Referenced by json_array_length().

{
    AlenState  *_state = (AlenState *) state;

    /* json structure check */
    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot get array length of a non-array")));
}

alen_scalar()

static void alen_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 1618 of file jsonfuncs.c.

References ereport, errcode(), errmsg(), ERROR, AlenState::lex, and JsonLexContext::lex_level.

Referenced by json_array_length().

{
    AlenState  *_state = (AlenState *) state;

    /* json structure check */
    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot get array length of a scalar")));
}

allocate_record_info()

static RecordIOData * allocate_record_info ( MemoryContext  mcxt, int  ncolumns  )

static

Definition at line 3055 of file jsonfuncs.c.

References RecordIOData::columns, InvalidOid, MemoryContextAlloc(), MemSet, RecordIOData::ncolumns, offsetof, RecordIOData::record_type, and RecordIOData::record_typmod.

Referenced by populate_record().

{
    RecordIOData *data = (RecordIOData *)
    MemoryContextAlloc(mcxt,
                       offsetof(RecordIOData, columns) +
                       ncolumns * sizeof(ColumnIOData));

    data->record_type = InvalidOid;
    data->record_typmod = 0;
    data->ncolumns = ncolumns;
    MemSet(data->columns, 0, sizeof(ColumnIOData) * ncolumns);

    return data;
}

each_array_start()

static void each_array_start ( void *  state )

static

Definition at line 1941 of file jsonfuncs.c.

References ereport, errcode(), errmsg(), ERROR, EachState::lex, and JsonLexContext::lex_level.

Referenced by each_worker().

{
    EachState  *_state = (EachState *) state;

    /* json structure check */
    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot deconstruct an array as an object")));
}

each_object_field_end()

static void each_object_field_end ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 1895 of file jsonfuncs.c.

References cstring_to_text_with_len(), CStringGetTextDatum, heap_form_tuple(), EachState::lex, JsonLexContext::lex_level, MemoryContextReset(), MemoryContextSwitchTo(), EachState::next_scalar, EachState::normalize_results, EachState::normalized_scalar, PointerGetDatum, JsonLexContext::prev_token_terminator, EachState::result_start, EachState::ret_tdesc, EachState::tmp_cxt, EachState::tuple_store, tuplestore_puttuple(), val, and values.

Referenced by each_worker().

{
    EachState  *_state = (EachState *) state;
    MemoryContext old_cxt;
    int         len;
    text       *val;
    HeapTuple   tuple;
    Datum       values[2];
    bool        nulls[2] = {false, false};

    /* skip over nested objects */
    if (_state->lex->lex_level != 1)
        return;

    /* use the tmp context so we can clean up after each tuple is done */
    old_cxt = MemoryContextSwitchTo(_state->tmp_cxt);

    values[0] = CStringGetTextDatum(fname);

    if (isnull && _state->normalize_results)
    {
        nulls[1] = true;
        values[1] = (Datum) 0;
    }
    else if (_state->next_scalar)
    {
        values[1] = CStringGetTextDatum(_state->normalized_scalar);
        _state->next_scalar = false;
    }
    else
    {
        len = _state->lex->prev_token_terminator - _state->result_start;
        val = cstring_to_text_with_len(_state->result_start, len);
        values[1] = PointerGetDatum(val);
    }

    tuple = heap_form_tuple(_state->ret_tdesc, values, nulls);

    tuplestore_puttuple(_state->tuple_store, tuple);

    /* clean up and switch back */
    MemoryContextSwitchTo(old_cxt);
    MemoryContextReset(_state->tmp_cxt);
}

each_object_field_start()

static void each_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 1875 of file jsonfuncs.c.

References JSON_TOKEN_STRING, EachState::lex, JsonLexContext::lex_level, EachState::next_scalar, EachState::normalize_results, EachState::result_start, JsonLexContext::token_start, and JsonLexContext::token_type.

Referenced by each_worker().

{
    EachState  *_state = (EachState *) state;

    /* save a pointer to where the value starts */
    if (_state->lex->lex_level == 1)
    {
        /*
         * next_scalar will be reset in the object_field_end handler, and
         * since we know the value is a scalar there is no danger of it being
         * on while recursing down the tree.
         */
        if (_state->normalize_results && _state->lex->token_type == JSON_TOKEN_STRING)
            _state->next_scalar = true;
        else
            _state->result_start = _state->lex->token_start;
    }
}

each_scalar()

static void each_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 1953 of file jsonfuncs.c.

References ereport, errcode(), errmsg(), ERROR, EachState::lex, JsonLexContext::lex_level, EachState::next_scalar, and EachState::normalized_scalar.

Referenced by each_worker().

{
    EachState  *_state = (EachState *) state;

    /* json structure check */
    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot deconstruct a scalar")));

    /* supply de-escaped value if required */
    if (_state->next_scalar)
        _state->normalized_scalar = token;
}

each_worker()

static Datum each_worker ( FunctionCallInfo  fcinfo, bool  as_text  )

static

Definition at line 1811 of file jsonfuncs.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ReturnSetInfo::allowedModes, JsonSemAction::array_start, BlessTupleDesc(), CreateTupleDescCopy(), CurrentMemoryContext, each_array_start(), each_object_field_end(), each_object_field_start(), each_scalar(), ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, ereport, errcode(), errmsg(), ERROR, ReturnSetInfo::expectedDesc, get_call_result_type(), IsA, OkeysState::lex, EachState::lex, makeJsonLexContext(), MemoryContextDelete(), MemoryContextSwitchTo(), EachState::next_scalar, EachState::normalize_results, JsonSemAction::object_field_end, JsonSemAction::object_field_start, palloc0(), PG_GETARG_TEXT_PP, pg_parse_json(), PG_RETURN_NULL, FunctionCallInfoData::resultinfo, EachState::ret_tdesc, ReturnSetInfo::returnMode, JsonSemAction::scalar, JsonSemAction::semstate, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Random, EachState::tmp_cxt, EachState::tuple_store, tuplestore_begin_heap(), and work_mem.

Referenced by json_each(), and json_each_text().

{
    text       *json = PG_GETARG_TEXT_PP(0);
    JsonLexContext *lex;
    JsonSemAction *sem;
    ReturnSetInfo *rsi;
    MemoryContext old_cxt;
    TupleDesc   tupdesc;
    EachState  *state;

    lex = makeJsonLexContext(json, true);
    state = palloc0(sizeof(EachState));
    sem = palloc0(sizeof(JsonSemAction));

    rsi = (ReturnSetInfo *) fcinfo->resultinfo;

    if (!rsi || !IsA(rsi, ReturnSetInfo) ||
        (rsi->allowedModes & SFRM_Materialize) == 0 ||
        rsi->expectedDesc == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that "
                        "cannot accept a set")));

    rsi->returnMode = SFRM_Materialize;

    (void) get_call_result_type(fcinfo, NULL, &tupdesc);

    /* make these in a sufficiently long-lived memory context */
    old_cxt = MemoryContextSwitchTo(rsi->econtext->ecxt_per_query_memory);

    state->ret_tdesc = CreateTupleDescCopy(tupdesc);
    BlessTupleDesc(state->ret_tdesc);
    state->tuple_store =
        tuplestore_begin_heap(rsi->allowedModes & SFRM_Materialize_Random,
                              false, work_mem);

    MemoryContextSwitchTo(old_cxt);

    sem->semstate = (void *) state;
    sem->array_start = each_array_start;
    sem->scalar = each_scalar;
    sem->object_field_start = each_object_field_start;
    sem->object_field_end = each_object_field_end;

    state->normalize_results = as_text;
    state->next_scalar = false;
    state->lex = lex;
    state->tmp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                           "json_each temporary cxt",
                                           ALLOCSET_DEFAULT_SIZES);

    pg_parse_json(lex, sem);

    MemoryContextDelete(state->tmp_cxt);

    rsi->setResult = state->tuple_store;
    rsi->setDesc = state->ret_tdesc;

    PG_RETURN_NULL();
}

each_worker_jsonb()

static Datum each_worker_jsonb ( FunctionCallInfo  fcinfo, const char *  funcname, bool  as_text  )

static

Definition at line 1674 of file jsonfuncs.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ReturnSetInfo::allowedModes, Assert, BlessTupleDesc(), CreateTupleDescCopy(), cstring_to_text_with_len(), CurrentMemoryContext, StringInfoData::data, ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, ereport, errcode(), errmsg(), ERROR, ReturnSetInfo::expectedDesc, get_call_result_type(), heap_form_tuple(), IsA, JB_ROOT_IS_OBJECT, jbvNull, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbToCString(), JsonbValueToJsonb(), StringInfoData::len, makeStringInfo(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), PG_GETARG_JSONB_P, PG_RETURN_NULL, PointerGetDatum, FunctionCallInfoData::resultinfo, ReturnSetInfo::returnMode, Jsonb::root, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Random, tuplestore_begin_heap(), tuplestore_puttuple(), JsonbValue::type, TYPEFUNC_COMPOSITE, JsonbValue::val, val, values, WJB_DONE, WJB_KEY, and work_mem.

Referenced by jsonb_each(), and jsonb_each_text().

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    ReturnSetInfo *rsi;
    Tuplestorestate *tuple_store;
    TupleDesc   tupdesc;
    TupleDesc   ret_tdesc;
    MemoryContext old_cxt,
                tmp_cxt;
    bool        skipNested = false;
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken r;

    if (!JB_ROOT_IS_OBJECT(jb))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot call %s on a non-object",
                        funcname)));

    rsi = (ReturnSetInfo *) fcinfo->resultinfo;

    if (!rsi || !IsA(rsi, ReturnSetInfo) ||
        (rsi->allowedModes & SFRM_Materialize) == 0 ||
        rsi->expectedDesc == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that "
                        "cannot accept a set")));

    rsi->returnMode = SFRM_Materialize;

    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("function returning record called in context "
                        "that cannot accept type record")));

    old_cxt = MemoryContextSwitchTo(rsi->econtext->ecxt_per_query_memory);

    ret_tdesc = CreateTupleDescCopy(tupdesc);
    BlessTupleDesc(ret_tdesc);
    tuple_store =
        tuplestore_begin_heap(rsi->allowedModes & SFRM_Materialize_Random,
                              false, work_mem);

    MemoryContextSwitchTo(old_cxt);

    tmp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                    "jsonb_each temporary cxt",
                                    ALLOCSET_DEFAULT_SIZES);

    it = JsonbIteratorInit(&jb->root);

    while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
    {
        skipNested = true;

        if (r == WJB_KEY)
        {
            text       *key;
            HeapTuple   tuple;
            Datum       values[2];
            bool        nulls[2] = {false, false};

            /* Use the tmp context so we can clean up after each tuple is done */
            old_cxt = MemoryContextSwitchTo(tmp_cxt);

            key = cstring_to_text_with_len(v.val.string.val, v.val.string.len);

            /*
             * The next thing the iterator fetches should be the value, no
             * matter what shape it is.
             */
            r = JsonbIteratorNext(&it, &v, skipNested);
            Assert(r != WJB_DONE);

            values[0] = PointerGetDatum(key);

            if (as_text)
            {
                if (v.type == jbvNull)
                {
                    /* a json null is an sql null in text mode */
                    nulls[1] = true;
                    values[1] = (Datum) NULL;
                }
                else
                {
                    text       *sv;

                    if (v.type == jbvString)
                    {
                        /* In text mode, scalar strings should be dequoted */
                        sv = cstring_to_text_with_len(v.val.string.val, v.val.string.len);
                    }
                    else
                    {
                        /* Turn anything else into a json string */
                        StringInfo  jtext = makeStringInfo();
                        Jsonb      *jb = JsonbValueToJsonb(&v);

                        (void) JsonbToCString(jtext, &jb->root, 0);
                        sv = cstring_to_text_with_len(jtext->data, jtext->len);
                    }

                    values[1] = PointerGetDatum(sv);
                }
            }
            else
            {
                /* Not in text mode, just return the Jsonb */
                Jsonb      *val = JsonbValueToJsonb(&v);

                values[1] = PointerGetDatum(val);
            }

            tuple = heap_form_tuple(ret_tdesc, values, nulls);

            tuplestore_puttuple(tuple_store, tuple);

            /* clean up and switch back */
            MemoryContextSwitchTo(old_cxt);
            MemoryContextReset(tmp_cxt);
        }
    }

    MemoryContextDelete(tmp_cxt);

    rsi->setResult = tuple_store;
    rsi->setDesc = ret_tdesc;

    PG_RETURN_NULL();
}

elements_array_element_end()

static void elements_array_element_end ( void *  state, bool  isnull  )

static

Definition at line 2211 of file jsonfuncs.c.

References cstring_to_text_with_len(), CStringGetTextDatum, heap_form_tuple(), ElementsState::lex, JsonLexContext::lex_level, MemoryContextReset(), MemoryContextSwitchTo(), ElementsState::next_scalar, ElementsState::normalize_results, ElementsState::normalized_scalar, PointerGetDatum, JsonLexContext::prev_token_terminator, ElementsState::result_start, ElementsState::ret_tdesc, ElementsState::tmp_cxt, ElementsState::tuple_store, tuplestore_puttuple(), val, and values.

Referenced by elements_worker().

{
    ElementsState *_state = (ElementsState *) state;
    MemoryContext old_cxt;
    int         len;
    text       *val;
    HeapTuple   tuple;
    Datum       values[1];
    bool        nulls[1] = {false};

    /* skip over nested objects */
    if (_state->lex->lex_level != 1)
        return;

    /* use the tmp context so we can clean up after each tuple is done */
    old_cxt = MemoryContextSwitchTo(_state->tmp_cxt);

    if (isnull && _state->normalize_results)
    {
        nulls[0] = true;
        values[0] = (Datum) NULL;
    }
    else if (_state->next_scalar)
    {
        values[0] = CStringGetTextDatum(_state->normalized_scalar);
        _state->next_scalar = false;
    }
    else
    {
        len = _state->lex->prev_token_terminator - _state->result_start;
        val = cstring_to_text_with_len(_state->result_start, len);
        values[0] = PointerGetDatum(val);
    }

    tuple = heap_form_tuple(_state->ret_tdesc, values, nulls);

    tuplestore_puttuple(_state->tuple_store, tuple);

    /* clean up and switch back */
    MemoryContextSwitchTo(old_cxt);
    MemoryContextReset(_state->tmp_cxt);
}

elements_array_element_start()

static void elements_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 2191 of file jsonfuncs.c.

References JSON_TOKEN_STRING, ElementsState::lex, JsonLexContext::lex_level, ElementsState::next_scalar, ElementsState::normalize_results, ElementsState::result_start, JsonLexContext::token_start, and JsonLexContext::token_type.

Referenced by elements_worker().

{
    ElementsState *_state = (ElementsState *) state;

    /* save a pointer to where the value starts */
    if (_state->lex->lex_level == 1)
    {
        /*
         * next_scalar will be reset in the array_element_end handler, and
         * since we know the value is a scalar there is no danger of it being
         * on while recursing down the tree.
         */
        if (_state->normalize_results && _state->lex->token_type == JSON_TOKEN_STRING)
            _state->next_scalar = true;
        else
            _state->result_start = _state->lex->token_start;
    }
}

elements_object_start()

static void elements_object_start ( void *  state )

static

Definition at line 2255 of file jsonfuncs.c.

References ereport, errcode(), errmsg(), ERROR, ElementsState::function_name, ElementsState::lex, and JsonLexContext::lex_level.

Referenced by elements_worker().

{
    ElementsState *_state = (ElementsState *) state;

    /* json structure check */
    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot call %s on a non-array",
                        _state->function_name)));
}

elements_scalar()

static void elements_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 2268 of file jsonfuncs.c.

References ereport, errcode(), errmsg(), ERROR, ElementsState::function_name, ElementsState::lex, JsonLexContext::lex_level, ElementsState::next_scalar, and ElementsState::normalized_scalar.

Referenced by elements_worker().

{
    ElementsState *_state = (ElementsState *) state;

    /* json structure check */
    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot call %s on a scalar",
                        _state->function_name)));

    /* supply de-escaped value if required */
    if (_state->next_scalar)
        _state->normalized_scalar = token;
}

elements_worker()

static Datum elements_worker ( FunctionCallInfo  fcinfo, const char *  funcname, bool  as_text  )

static

Definition at line 2125 of file jsonfuncs.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ReturnSetInfo::allowedModes, JsonSemAction::array_element_end, JsonSemAction::array_element_start, BlessTupleDesc(), CreateTupleDescCopy(), CurrentMemoryContext, ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, elements_array_element_end(), elements_array_element_start(), elements_object_start(), elements_scalar(), ereport, errcode(), errmsg(), ERROR, ReturnSetInfo::expectedDesc, ElementsState::function_name, IsA, OkeysState::lex, ElementsState::lex, makeJsonLexContext(), MemoryContextDelete(), MemoryContextSwitchTo(), ElementsState::next_scalar, ElementsState::normalize_results, JsonSemAction::object_start, palloc0(), PG_GETARG_TEXT_PP, pg_parse_json(), PG_RETURN_NULL, FunctionCallInfoData::resultinfo, ElementsState::ret_tdesc, ReturnSetInfo::returnMode, JsonSemAction::scalar, JsonSemAction::semstate, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Random, ElementsState::tmp_cxt, ElementsState::tuple_store, tuplestore_begin_heap(), and work_mem.

Referenced by json_array_elements(), and json_array_elements_text().

{
    text       *json = PG_GETARG_TEXT_PP(0);

    /* elements only needs escaped strings when as_text */
    JsonLexContext *lex = makeJsonLexContext(json, as_text);
    JsonSemAction *sem;
    ReturnSetInfo *rsi;
    MemoryContext old_cxt;
    TupleDesc   tupdesc;
    ElementsState *state;

    state = palloc0(sizeof(ElementsState));
    sem = palloc0(sizeof(JsonSemAction));

    rsi = (ReturnSetInfo *) fcinfo->resultinfo;

    if (!rsi || !IsA(rsi, ReturnSetInfo) ||
        (rsi->allowedModes & SFRM_Materialize) == 0 ||
        rsi->expectedDesc == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that "
                        "cannot accept a set")));

    rsi->returnMode = SFRM_Materialize;

    /* it's a simple type, so don't use get_call_result_type() */
    tupdesc = rsi->expectedDesc;

    /* make these in a sufficiently long-lived memory context */
    old_cxt = MemoryContextSwitchTo(rsi->econtext->ecxt_per_query_memory);

    state->ret_tdesc = CreateTupleDescCopy(tupdesc);
    BlessTupleDesc(state->ret_tdesc);
    state->tuple_store =
        tuplestore_begin_heap(rsi->allowedModes & SFRM_Materialize_Random,
                              false, work_mem);

    MemoryContextSwitchTo(old_cxt);

    sem->semstate = (void *) state;
    sem->object_start = elements_object_start;
    sem->scalar = elements_scalar;
    sem->array_element_start = elements_array_element_start;
    sem->array_element_end = elements_array_element_end;

    state->function_name = funcname;
    state->normalize_results = as_text;
    state->next_scalar = false;
    state->lex = lex;
    state->tmp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                           "json_array_elements temporary cxt",
                                           ALLOCSET_DEFAULT_SIZES);

    pg_parse_json(lex, sem);

    MemoryContextDelete(state->tmp_cxt);

    rsi->setResult = state->tuple_store;
    rsi->setDesc = state->ret_tdesc;

    PG_RETURN_NULL();
}

elements_worker_jsonb()

static Datum elements_worker_jsonb ( FunctionCallInfo  fcinfo, const char *  funcname, bool  as_text  )

static

Definition at line 1989 of file jsonfuncs.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ReturnSetInfo::allowedModes, BlessTupleDesc(), CreateTupleDescCopy(), cstring_to_text_with_len(), CurrentMemoryContext, StringInfoData::data, ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, ereport, errcode(), errmsg(), ERROR, ReturnSetInfo::expectedDesc, heap_form_tuple(), IsA, JB_ROOT_IS_ARRAY, JB_ROOT_IS_SCALAR, jbvNull, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbToCString(), JsonbValueToJsonb(), StringInfoData::len, makeStringInfo(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), PG_GETARG_JSONB_P, PG_RETURN_NULL, PointerGetDatum, FunctionCallInfoData::resultinfo, ReturnSetInfo::returnMode, Jsonb::root, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Random, tuplestore_begin_heap(), tuplestore_puttuple(), JsonbValue::type, JsonbValue::val, val, values, WJB_DONE, WJB_ELEM, and work_mem.

Referenced by jsonb_array_elements(), and jsonb_array_elements_text().

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    ReturnSetInfo *rsi;
    Tuplestorestate *tuple_store;
    TupleDesc   tupdesc;
    TupleDesc   ret_tdesc;
    MemoryContext old_cxt,
                tmp_cxt;
    bool        skipNested = false;
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken r;

    if (JB_ROOT_IS_SCALAR(jb))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot extract elements from a scalar")));
    else if (!JB_ROOT_IS_ARRAY(jb))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot extract elements from an object")));

    rsi = (ReturnSetInfo *) fcinfo->resultinfo;

    if (!rsi || !IsA(rsi, ReturnSetInfo) ||
        (rsi->allowedModes & SFRM_Materialize) == 0 ||
        rsi->expectedDesc == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that "
                        "cannot accept a set")));

    rsi->returnMode = SFRM_Materialize;

    /* it's a simple type, so don't use get_call_result_type() */
    tupdesc = rsi->expectedDesc;

    old_cxt = MemoryContextSwitchTo(rsi->econtext->ecxt_per_query_memory);

    ret_tdesc = CreateTupleDescCopy(tupdesc);
    BlessTupleDesc(ret_tdesc);
    tuple_store =
        tuplestore_begin_heap(rsi->allowedModes & SFRM_Materialize_Random,
                              false, work_mem);

    MemoryContextSwitchTo(old_cxt);

    tmp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                    "jsonb_array_elements temporary cxt",
                                    ALLOCSET_DEFAULT_SIZES);

    it = JsonbIteratorInit(&jb->root);

    while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
    {
        skipNested = true;

        if (r == WJB_ELEM)
        {
            HeapTuple   tuple;
            Datum       values[1];
            bool        nulls[1] = {false};

            /* use the tmp context so we can clean up after each tuple is done */
            old_cxt = MemoryContextSwitchTo(tmp_cxt);

            if (!as_text)
            {
                Jsonb      *val = JsonbValueToJsonb(&v);

                values[0] = PointerGetDatum(val);
            }
            else
            {
                if (v.type == jbvNull)
                {
                    /* a json null is an sql null in text mode */
                    nulls[0] = true;
                    values[0] = (Datum) NULL;
                }
                else
                {
                    text       *sv;

                    if (v.type == jbvString)
                    {
                        /* in text mode scalar strings should be dequoted */
                        sv = cstring_to_text_with_len(v.val.string.val, v.val.string.len);
                    }
                    else
                    {
                        /* turn anything else into a json string */
                        StringInfo  jtext = makeStringInfo();
                        Jsonb      *jb = JsonbValueToJsonb(&v);

                        (void) JsonbToCString(jtext, &jb->root, 0);
                        sv = cstring_to_text_with_len(jtext->data, jtext->len);
                    }

                    values[0] = PointerGetDatum(sv);
                }
            }

            tuple = heap_form_tuple(ret_tdesc, values, nulls);

            tuplestore_puttuple(tuple_store, tuple);

            /* clean up and switch back */
            MemoryContextSwitchTo(old_cxt);
            MemoryContextReset(tmp_cxt);
        }
    }

    MemoryContextDelete(tmp_cxt);

    rsi->setResult = tuple_store;
    rsi->setDesc = ret_tdesc;

    PG_RETURN_NULL();
}

findJsonbValueFromContainerLen()

static JsonbValue * findJsonbValueFromContainerLen ( JsonbContainer *  container, uint32  flags, char *  key, uint32  keylen  )

static

Definition at line 3893 of file jsonfuncs.c.

References findJsonbValueFromContainer(), jbvString, JsonbValue::type, and JsonbValue::val.

Referenced by get_jsonb_path_all(), JsObjectGetField(), jsonb_object_field(), and jsonb_object_field_text().

{
    JsonbValue  k;

    k.type = jbvString;
    k.val.string.val = key;
    k.val.string.len = keylen;

    return findJsonbValueFromContainer(container, flags, &k);
}

get_array_element_end()

static void get_array_element_end ( void *  state, bool  isnull  )

static

Definition at line 1293 of file jsonfuncs.c.

References GetState::array_cur_index, cstring_to_text_with_len(), GetState::lex, JsonLexContext::lex_level, GetState::normalize_results, GetState::path_indexes, GetState::pathok, JsonLexContext::prev_token_terminator, GetState::result_start, and GetState::tresult.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    bool        get_last = false;
    int         lex_level = _state->lex->lex_level;

    /* same tests as in get_array_element_start */
    if (lex_level <= _state->npath &&
        _state->pathok[lex_level - 1] &&
        _state->path_indexes != NULL &&
        _state->array_cur_index[lex_level - 1] == _state->path_indexes[lex_level - 1])
    {
        if (lex_level < _state->npath)
        {
            /* done with this element so reset pathok */
            _state->pathok[lex_level] = false;
        }
        else
        {
            /* end of path, so we want this value */
            get_last = true;
        }
    }

    /* same logic as for objects */
    if (get_last && _state->result_start != NULL)
    {
        if (isnull && _state->normalize_results)
            _state->tresult = (text *) NULL;
        else
        {
            char       *start = _state->result_start;
            int         len = _state->lex->prev_token_terminator - start;

            _state->tresult = cstring_to_text_with_len(start, len);
        }

        _state->result_start = NULL;
    }
}

get_array_element_start()

static void get_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 1247 of file jsonfuncs.c.

References GetState::array_cur_index, JSON_TOKEN_STRING, GetState::lex, JsonLexContext::lex_level, GetState::next_scalar, GetState::normalize_results, GetState::path_indexes, GetState::pathok, GetState::result_start, JsonLexContext::token_start, JsonLexContext::token_type, and GetState::tresult.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    bool        get_next = false;
    int         lex_level = _state->lex->lex_level;

    /* Update array element counter */
    if (lex_level <= _state->npath)
        _state->array_cur_index[lex_level - 1]++;

    if (lex_level <= _state->npath &&
        _state->pathok[lex_level - 1] &&
        _state->path_indexes != NULL &&
        _state->array_cur_index[lex_level - 1] == _state->path_indexes[lex_level - 1])
    {
        if (lex_level < _state->npath)
        {
            /* if not at end of path just mark path ok */
            _state->pathok[lex_level] = true;
        }
        else
        {
            /* end of path, so we want this value */
            get_next = true;
        }
    }

    /* same logic as for objects */
    if (get_next)
    {
        _state->tresult = NULL;
        _state->result_start = NULL;

        if (_state->normalize_results &&
            _state->lex->token_type == JSON_TOKEN_STRING)
        {
            _state->next_scalar = true;
        }
        else
        {
            _state->result_start = _state->lex->token_start;
        }
    }
}

get_array_end()

static void get_array_end ( void *  state )

static

Definition at line 1231 of file jsonfuncs.c.

References cstring_to_text_with_len(), GetState::lex, JsonLexContext::lex_level, GetState::npath, JsonLexContext::prev_token_terminator, GetState::result_start, and GetState::tresult.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    int         lex_level = _state->lex->lex_level;

    if (lex_level == 0 && _state->npath == 0)
    {
        /* Special case: return the entire array */
        char       *start = _state->result_start;
        int         len = _state->lex->prev_token_terminator - start;

        _state->tresult = cstring_to_text_with_len(start, len);
    }
}

get_array_start()

static void get_array_start ( void *  state )

static

Definition at line 1198 of file jsonfuncs.c.

References GetState::array_cur_index, json_count_array_elements(), GetState::lex, JsonLexContext::lex_level, GetState::npath, GetState::path_indexes, GetState::result_start, and JsonLexContext::token_start.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    int         lex_level = _state->lex->lex_level;

    if (lex_level < _state->npath)
    {
        /* Initialize counting of elements in this array */
        _state->array_cur_index[lex_level] = -1;

        /* INT_MIN value is reserved to represent invalid subscript */
        if (_state->path_indexes[lex_level] < 0 &&
            _state->path_indexes[lex_level] != INT_MIN)
        {
            /* Negative subscript -- convert to positive-wise subscript */
            int         nelements = json_count_array_elements(_state->lex);

            if (-_state->path_indexes[lex_level] <= nelements)
                _state->path_indexes[lex_level] += nelements;
        }
    }
    else if (lex_level == 0 && _state->npath == 0)
    {
        /*
         * Special case: we should match the entire array.  We only need this
         * at the outermost level because at nested levels the match will have
         * been started by the outer field or array element callback.
         */
        _state->result_start = _state->lex->token_start;
    }
}

get_json_object_as_hash()

static HTAB * get_json_object_as_hash ( char *  json, int  len, const char *  funcname  )

static

Definition at line 3341 of file jsonfuncs.c.

References JsonSemAction::array_start, CurrentMemoryContext, HASHCTL::entrysize, JHashState::function_name, JHashState::hash, hash_array_start(), HASH_CONTEXT, hash_create(), HASH_ELEM, hash_object_field_end(), hash_object_field_start(), hash_scalar(), HASHCTL::hcxt, HASHCTL::keysize, OkeysState::lex, JHashState::lex, makeJsonLexContextCstringLen(), NAMEDATALEN, JsonSemAction::object_field_end, JsonSemAction::object_field_start, palloc0(), pg_parse_json(), JsonSemAction::scalar, and JsonSemAction::semstate.

Referenced by JsValueToJsObject().

{
    HASHCTL     ctl;
    HTAB       *tab;
    JHashState *state;
    JsonLexContext *lex = makeJsonLexContextCstringLen(json, len, true);
    JsonSemAction *sem;

    memset(&ctl, 0, sizeof(ctl));
    ctl.keysize = NAMEDATALEN;
    ctl.entrysize = sizeof(JsonHashEntry);
    ctl.hcxt = CurrentMemoryContext;
    tab = hash_create("json object hashtable",
                      100,
                      &ctl,
                      HASH_ELEM | HASH_CONTEXT);

    state = palloc0(sizeof(JHashState));
    sem = palloc0(sizeof(JsonSemAction));

    state->function_name = funcname;
    state->hash = tab;
    state->lex = lex;

    sem->semstate = (void *) state;
    sem->array_start = hash_array_start;
    sem->scalar = hash_scalar;
    sem->object_field_start = hash_object_field_start;
    sem->object_field_end = hash_object_field_end;

    pg_parse_json(lex, sem);

    return tab;
}

get_jsonb_path_all()

static Datum get_jsonb_path_all ( FunctionCallInfo  fcinfo, bool  as_text  )

static

Definition at line 1388 of file jsonfuncs.c.

References array_contains_nulls(), Assert, cstring_to_text(), cstring_to_text_with_len(), deconstruct_array(), elog, ERROR, findJsonbValueFromContainerLen(), getIthJsonbValueFromContainer(), i, JB_FOBJECT, JB_ROOT_IS_ARRAY, JB_ROOT_IS_OBJECT, JB_ROOT_IS_SCALAR, jbvArray, jbvBinary, jbvNull, jbvObject, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbToCString(), JsonbValueToJsonb(), JsonContainerIsArray, JsonContainerSize, PG_GETARG_ARRAYTYPE_P, PG_GETARG_JSONB_P, PG_RETURN_JSONB_P, PG_RETURN_NULL, PG_RETURN_TEXT_P, Jsonb::root, TextDatumGetCString, JsonbValue::type, JsonbValue::val, VARDATA, VARHDRSZ, VARSIZE, WJB_BEGIN_ARRAY, and WJB_BEGIN_OBJECT.

Referenced by jsonb_extract_path(), and jsonb_extract_path_text().

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    ArrayType  *path = PG_GETARG_ARRAYTYPE_P(1);
    Jsonb      *res;
    Datum      *pathtext;
    bool       *pathnulls;
    int         npath;
    int         i;
    bool        have_object = false,
                have_array = false;
    JsonbValue *jbvp = NULL;
    JsonbValue  tv;
    JsonbContainer *container;

    /*
     * If the array contains any null elements, return NULL, on the grounds
     * that you'd have gotten NULL if any RHS value were NULL in a nested
     * series of applications of the -> operator.  (Note: because we also
     * return NULL for error cases such as no-such-field, this is true
     * regardless of the contents of the rest of the array.)
     */
    if (array_contains_nulls(path))
        PG_RETURN_NULL();

    deconstruct_array(path, TEXTOID, -1, false, 'i',
                      &pathtext, &pathnulls, &npath);

    /* Identify whether we have object, array, or scalar at top-level */
    container = &jb->root;

    if (JB_ROOT_IS_OBJECT(jb))
        have_object = true;
    else if (JB_ROOT_IS_ARRAY(jb) && !JB_ROOT_IS_SCALAR(jb))
        have_array = true;
    else
    {
        Assert(JB_ROOT_IS_ARRAY(jb) && JB_ROOT_IS_SCALAR(jb));
        /* Extract the scalar value, if it is what we'll return */
        if (npath <= 0)
            jbvp = getIthJsonbValueFromContainer(container, 0);
    }

    /*
     * If the array is empty, return the entire LHS object, on the grounds
     * that we should do zero field or element extractions.  For the
     * non-scalar case we can just hand back the object without much work. For
     * the scalar case, fall through and deal with the value below the loop.
     * (This inconsistency arises because there's no easy way to generate a
     * JsonbValue directly for root-level containers.)
     */
    if (npath <= 0 && jbvp == NULL)
    {
        if (as_text)
        {
            PG_RETURN_TEXT_P(cstring_to_text(JsonbToCString(NULL,
                                                            container,
                                                            VARSIZE(jb))));
        }
        else
        {
            /* not text mode - just hand back the jsonb */
            PG_RETURN_JSONB_P(jb);
        }
    }

    for (i = 0; i < npath; i++)
    {
        if (have_object)
        {
            jbvp = findJsonbValueFromContainerLen(container,
                                                  JB_FOBJECT,
                                                  VARDATA(pathtext[i]),
                                                  VARSIZE(pathtext[i]) - VARHDRSZ);
        }
        else if (have_array)
        {
            long        lindex;
            uint32      index;
            char       *indextext = TextDatumGetCString(pathtext[i]);
            char       *endptr;

            errno = 0;
            lindex = strtol(indextext, &endptr, 10);
            if (endptr == indextext || *endptr != '\0' || errno != 0 ||
                lindex > INT_MAX || lindex < INT_MIN)
                PG_RETURN_NULL();

            if (lindex >= 0)
            {
                index = (uint32) lindex;
            }
            else
            {
                /* Handle negative subscript */
                uint32      nelements;

                /* Container must be array, but make sure */
                if (!JsonContainerIsArray(container))
                    elog(ERROR, "not a jsonb array");

                nelements = JsonContainerSize(container);

                if (-lindex > nelements)
                    PG_RETURN_NULL();
                else
                    index = nelements + lindex;
            }

            jbvp = getIthJsonbValueFromContainer(container, index);
        }
        else
        {
            /* scalar, extraction yields a null */
            PG_RETURN_NULL();
        }

        if (jbvp == NULL)
            PG_RETURN_NULL();
        else if (i == npath - 1)
            break;

        if (jbvp->type == jbvBinary)
        {
            JsonbIterator *it = JsonbIteratorInit((JsonbContainer *) jbvp->val.binary.data);
            JsonbIteratorToken r;

            r = JsonbIteratorNext(&it, &tv, true);
            container = (JsonbContainer *) jbvp->val.binary.data;
            have_object = r == WJB_BEGIN_OBJECT;
            have_array = r == WJB_BEGIN_ARRAY;
        }
        else
        {
            have_object = jbvp->type == jbvObject;
            have_array = jbvp->type == jbvArray;
        }
    }

    if (as_text)
    {
        /* special-case outputs for string and null values */
        if (jbvp->type == jbvString)
            PG_RETURN_TEXT_P(cstring_to_text_with_len(jbvp->val.string.val,
                                                      jbvp->val.string.len));
        if (jbvp->type == jbvNull)
            PG_RETURN_NULL();
    }

    res = JsonbValueToJsonb(jbvp);

    if (as_text)
    {
        PG_RETURN_TEXT_P(cstring_to_text(JsonbToCString(NULL,
                                                        &res->root,
                                                        VARSIZE(res))));
    }
    else
    {
        /* not text mode - just hand back the jsonb */
        PG_RETURN_JSONB_P(res);
    }
}

get_object_end()

static void get_object_end ( void *  state )

static

Definition at line 1088 of file jsonfuncs.c.

References cstring_to_text_with_len(), GetState::lex, JsonLexContext::lex_level, GetState::npath, JsonLexContext::prev_token_terminator, GetState::result_start, and GetState::tresult.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    int         lex_level = _state->lex->lex_level;

    if (lex_level == 0 && _state->npath == 0)
    {
        /* Special case: return the entire object */
        char       *start = _state->result_start;
        int         len = _state->lex->prev_token_terminator - start;

        _state->tresult = cstring_to_text_with_len(start, len);
    }
}

get_object_field_end()

static void get_object_field_end ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 1149 of file jsonfuncs.c.

References cstring_to_text_with_len(), GetState::lex, JsonLexContext::lex_level, GetState::normalize_results, GetState::path_names, GetState::pathok, JsonLexContext::prev_token_terminator, GetState::result_start, and GetState::tresult.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    bool        get_last = false;
    int         lex_level = _state->lex->lex_level;

    /* same tests as in get_object_field_start */
    if (lex_level <= _state->npath &&
        _state->pathok[lex_level - 1] &&
        _state->path_names != NULL &&
        _state->path_names[lex_level - 1] != NULL &&
        strcmp(fname, _state->path_names[lex_level - 1]) == 0)
    {
        if (lex_level < _state->npath)
        {
            /* done with this field so reset pathok */
            _state->pathok[lex_level] = false;
        }
        else
        {
            /* end of path, so we want this value */
            get_last = true;
        }
    }

    /* for as_text scalar case, our work is already done */
    if (get_last && _state->result_start != NULL)
    {
        /*
         * make a text object from the string from the previously noted json
         * start up to the end of the previous token (the lexer is by now
         * ahead of us on whatever came after what we're interested in).
         */
        if (isnull && _state->normalize_results)
            _state->tresult = (text *) NULL;
        else
        {
            char       *start = _state->result_start;
            int         len = _state->lex->prev_token_terminator - start;

            _state->tresult = cstring_to_text_with_len(start, len);
        }

        /* this should be unnecessary but let's do it for cleanliness: */
        _state->result_start = NULL;
    }
}

get_object_field_start()

static void get_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 1104 of file jsonfuncs.c.

References JSON_TOKEN_STRING, GetState::lex, JsonLexContext::lex_level, GetState::next_scalar, GetState::normalize_results, GetState::path_names, GetState::pathok, GetState::result_start, JsonLexContext::token_start, JsonLexContext::token_type, and GetState::tresult.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    bool        get_next = false;
    int         lex_level = _state->lex->lex_level;

    if (lex_level <= _state->npath &&
        _state->pathok[lex_level - 1] &&
        _state->path_names != NULL &&
        _state->path_names[lex_level - 1] != NULL &&
        strcmp(fname, _state->path_names[lex_level - 1]) == 0)
    {
        if (lex_level < _state->npath)
        {
            /* if not at end of path just mark path ok */
            _state->pathok[lex_level] = true;
        }
        else
        {
            /* end of path, so we want this value */
            get_next = true;
        }
    }

    if (get_next)
    {
        /* this object overrides any previous matching object */
        _state->tresult = NULL;
        _state->result_start = NULL;

        if (_state->normalize_results &&
            _state->lex->token_type == JSON_TOKEN_STRING)
        {
            /* for as_text variants, tell get_scalar to set it for us */
            _state->next_scalar = true;
        }
        else
        {
            /* for non-as_text variants, just note the json starting point */
            _state->result_start = _state->lex->token_start;
        }
    }
}

get_object_start()

static void get_object_start ( void *  state )

static

Definition at line 1071 of file jsonfuncs.c.

References GetState::lex, JsonLexContext::lex_level, GetState::npath, GetState::result_start, and JsonLexContext::token_start.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    int         lex_level = _state->lex->lex_level;

    if (lex_level == 0 && _state->npath == 0)
    {
        /*
         * Special case: we should match the entire object.  We only need this
         * at outermost level because at nested levels the match will have
         * been started by the outer field or array element callback.
         */
        _state->result_start = _state->lex->token_start;
    }
}

get_path_all()

static Datum get_path_all ( FunctionCallInfo  fcinfo, bool  as_text  )

static

Definition at line 935 of file jsonfuncs.c.

References array_contains_nulls(), Assert, deconstruct_array(), get_worker(), i, palloc(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, OkeysState::result, and TextDatumGetCString.

Referenced by json_extract_path(), and json_extract_path_text().

{
    text       *json = PG_GETARG_TEXT_PP(0);
    ArrayType  *path = PG_GETARG_ARRAYTYPE_P(1);
    text       *result;
    Datum      *pathtext;
    bool       *pathnulls;
    int         npath;
    char      **tpath;
    int        *ipath;
    int         i;

    /*
     * If the array contains any null elements, return NULL, on the grounds
     * that you'd have gotten NULL if any RHS value were NULL in a nested
     * series of applications of the -> operator.  (Note: because we also
     * return NULL for error cases such as no-such-field, this is true
     * regardless of the contents of the rest of the array.)
     */
    if (array_contains_nulls(path))
        PG_RETURN_NULL();

    deconstruct_array(path, TEXTOID, -1, false, 'i',
                      &pathtext, &pathnulls, &npath);

    tpath = palloc(npath * sizeof(char *));
    ipath = palloc(npath * sizeof(int));

    for (i = 0; i < npath; i++)
    {
        Assert(!pathnulls[i]);
        tpath[i] = TextDatumGetCString(pathtext[i]);

        /*
         * we have no idea at this stage what structure the document is so
         * just convert anything in the path that we can to an integer and set
         * all the other integers to INT_MIN which will never match.
         */
        if (*tpath[i] != '\0')
        {
            long        ind;
            char       *endptr;

            errno = 0;
            ind = strtol(tpath[i], &endptr, 10);
            if (*endptr == '\0' && errno == 0 && ind <= INT_MAX && ind >= INT_MIN)
                ipath[i] = (int) ind;
            else
                ipath[i] = INT_MIN;
        }
        else
            ipath[i] = INT_MIN;
    }

    result = get_worker(json, tpath, ipath, npath, as_text);

    if (result != NULL)
        PG_RETURN_TEXT_P(result);
    else
        PG_RETURN_NULL();
}

get_scalar()

static void get_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 1335 of file jsonfuncs.c.

References cstring_to_text(), cstring_to_text_with_len(), JsonLexContext::input, JSON_TOKEN_NULL, JSON_TOKEN_STRING, GetState::lex, JsonLexContext::lex_level, GetState::next_scalar, GetState::normalize_results, GetState::npath, JsonLexContext::prev_token_terminator, and GetState::tresult.

Referenced by get_worker().

{
    GetState   *_state = (GetState *) state;
    int         lex_level = _state->lex->lex_level;

    /* Check for whole-object match */
    if (lex_level == 0 && _state->npath == 0)
    {
        if (_state->normalize_results && tokentype == JSON_TOKEN_STRING)
        {
            /* we want the de-escaped string */
            _state->next_scalar = true;
        }
        else if (_state->normalize_results && tokentype == JSON_TOKEN_NULL)
        {
            _state->tresult = (text *) NULL;
        }
        else
        {
            /*
             * This is a bit hokey: we will suppress whitespace after the
             * scalar token, but not whitespace before it.  Probably not worth
             * doing our own space-skipping to avoid that.
             */
            char       *start = _state->lex->input;
            int         len = _state->lex->prev_token_terminator - start;

            _state->tresult = cstring_to_text_with_len(start, len);
        }
    }

    if (_state->next_scalar)
    {
        /* a de-escaped text value is wanted, so supply it */
        _state->tresult = cstring_to_text(token);
        /* make sure the next call to get_scalar doesn't overwrite it */
        _state->next_scalar = false;
    }
}

get_worker()

static text * get_worker ( text *  json, char **  tpath, int *  ipath, int  npath, bool  normalize_results  )

static

Definition at line 1015 of file jsonfuncs.c.

References GetState::array_cur_index, JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, Assert, get_array_element_end(), get_array_element_start(), get_array_end(), get_array_start(), get_object_end(), get_object_field_end(), get_object_field_start(), get_object_start(), get_scalar(), OkeysState::lex, GetState::lex, makeJsonLexContext(), GetState::normalize_results, GetState::npath, JsonSemAction::object_end, JsonSemAction::object_field_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc(), palloc0(), GetState::path_indexes, GetState::path_names, GetState::pathok, pg_parse_json(), JsonSemAction::scalar, JsonSemAction::semstate, and GetState::tresult.

Referenced by get_path_all(), json_array_element(), json_array_element_text(), json_object_field(), and json_object_field_text().

{
    JsonLexContext *lex = makeJsonLexContext(json, true);
    JsonSemAction *sem = palloc0(sizeof(JsonSemAction));
    GetState   *state = palloc0(sizeof(GetState));

    Assert(npath >= 0);

    state->lex = lex;
    /* is it "_as_text" variant? */
    state->normalize_results = normalize_results;
    state->npath = npath;
    state->path_names = tpath;
    state->path_indexes = ipath;
    state->pathok = palloc0(sizeof(bool) * npath);
    state->array_cur_index = palloc(sizeof(int) * npath);

    if (npath > 0)
        state->pathok[0] = true;

    sem->semstate = (void *) state;

    /*
     * Not all variants need all the semantic routines. Only set the ones that
     * are actually needed for maximum efficiency.
     */
    sem->scalar = get_scalar;
    if (npath == 0)
    {
        sem->object_start = get_object_start;
        sem->object_end = get_object_end;
        sem->array_start = get_array_start;
        sem->array_end = get_array_end;
    }
    if (tpath != NULL)
    {
        sem->object_field_start = get_object_field_start;
        sem->object_field_end = get_object_field_end;
    }
    if (ipath != NULL)
    {
        sem->array_start = get_array_start;
        sem->array_element_start = get_array_element_start;
        sem->array_element_end = get_array_element_end;
    }

    pg_parse_json(lex, sem);

    return state->tresult;
}

hash_array_start()

static void hash_array_start ( void *  state )

static

Definition at line 3450 of file jsonfuncs.c.

References ereport, errcode(), errmsg(), ERROR, JHashState::function_name, JHashState::lex, and JsonLexContext::lex_level.

Referenced by get_json_object_as_hash().

{
    JHashState *_state = (JHashState *) state;

    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot call %s on an array", _state->function_name)));
}

hash_object_field_end()

static void hash_object_field_end ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 3401 of file jsonfuncs.c.

References Assert, JHashState::hash, HASH_ENTER, hash_search(), JSON_TOKEN_NULL, JHashState::lex, JsonLexContext::lex_level, NAMEDATALEN, palloc(), JsonLexContext::prev_token_terminator, JHashState::save_json_start, JHashState::saved_scalar, JHashState::saved_token_type, JsonHashEntry::type, JsonHashEntry::val, and val.

Referenced by get_json_object_as_hash().

{
    JHashState *_state = (JHashState *) state;
    JsonHashEntry *hashentry;
    bool        found;

    /*
     * Ignore nested fields.
     */
    if (_state->lex->lex_level > 1)
        return;

    /*
     * Ignore field names >= NAMEDATALEN - they can't match a record field.
     * (Note: without this test, the hash code would truncate the string at
     * NAMEDATALEN-1, and could then match against a similarly-truncated
     * record field name.  That would be a reasonable behavior, but this code
     * has previously insisted on exact equality, so we keep this behavior.)
     */
    if (strlen(fname) >= NAMEDATALEN)
        return;

    hashentry = hash_search(_state->hash, fname, HASH_ENTER, &found);

    /*
     * found being true indicates a duplicate. We don't do anything about
     * that, a later field with the same name overrides the earlier field.
     */

    hashentry->type = _state->saved_token_type;
    Assert(isnull == (hashentry->type == JSON_TOKEN_NULL));

    if (_state->save_json_start != NULL)
    {
        int         len = _state->lex->prev_token_terminator - _state->save_json_start;
        char       *val = palloc((len + 1) * sizeof(char));

        memcpy(val, _state->save_json_start, len);
        val[len] = '\0';
        hashentry->val = val;
    }
    else
    {
        /* must have had a scalar instead */
        hashentry->val = _state->saved_scalar;
    }
}

hash_object_field_start()

static void hash_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 3377 of file jsonfuncs.c.

References JSON_TOKEN_ARRAY_START, JSON_TOKEN_OBJECT_START, JHashState::lex, JsonLexContext::lex_level, JHashState::save_json_start, JHashState::saved_token_type, JsonLexContext::token_start, and JsonLexContext::token_type.

Referenced by get_json_object_as_hash().

{
    JHashState *_state = (JHashState *) state;

    if (_state->lex->lex_level > 1)
        return;

    /* remember token type */
    _state->saved_token_type = _state->lex->token_type;

    if (_state->lex->token_type == JSON_TOKEN_ARRAY_START ||
        _state->lex->token_type == JSON_TOKEN_OBJECT_START)
    {
        /* remember start position of the whole text of the subobject */
        _state->save_json_start = _state->lex->token_start;
    }
    else
    {
        /* must be a scalar */
        _state->save_json_start = NULL;
    }
}

hash_scalar()

static void hash_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 3461 of file jsonfuncs.c.

References Assert, ereport, errcode(), errmsg(), ERROR, JHashState::function_name, JHashState::lex, JsonLexContext::lex_level, JHashState::saved_scalar, and JHashState::saved_token_type.

Referenced by get_json_object_as_hash().

{
    JHashState *_state = (JHashState *) state;

    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot call %s on a scalar", _state->function_name)));

    if (_state->lex->lex_level == 1)
    {
        _state->saved_scalar = token;
        /* saved_token_type must already be set in hash_object_field_start() */
        Assert(_state->saved_token_type == tokentype);
    }
}

iterate_json_values()

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

Definition at line 5088 of file jsonfuncs.c.

References IterateJsonStringValuesState::action, generate_unaccent_rules::action, IterateJsonStringValuesState::action_state, IterateJsonStringValuesState::flags, iterate_values_object_field_start(), iterate_values_scalar(), OkeysState::lex, IterateJsonStringValuesState::lex, makeJsonLexContext(), JsonSemAction::object_field_start, palloc0(), pg_parse_json(), JsonSemAction::scalar, and JsonSemAction::semstate.

Referenced by json_to_tsvector_worker().

{
    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(lex, sem);
}

iterate_jsonb_values()

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

Definition at line 5020 of file jsonfuncs.c.

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().

{
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken type;

    it = JsonbIteratorInit(&jb->root);

    /*
     * Just recursively iterating over jsonb and call callback on all
     * correspoding 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;
        }
    }
}

iterate_values_object_field_start()

static void iterate_values_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 5138 of file jsonfuncs.c.

References IterateJsonStringValuesState::action, IterateJsonStringValuesState::action_state, IterateJsonStringValuesState::flags, jtiKey, pstrdup(), and val.

Referenced by iterate_json_values().

{
    IterateJsonStringValuesState *_state = (IterateJsonStringValuesState *) state;

    if (_state->flags & jtiKey)
    {
        char       *val = pstrdup(fname);

        _state->action(_state->action_state, val, strlen(val));
    }
}

iterate_values_scalar()

static void iterate_values_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 5112 of file jsonfuncs.c.

References IterateJsonStringValuesState::action, IterateJsonStringValuesState::action_state, IterateJsonStringValuesState::flags, JSON_TOKEN_FALSE, JSON_TOKEN_NUMBER, JSON_TOKEN_STRING, JSON_TOKEN_TRUE, jtiBool, jtiNumeric, and jtiString.

Referenced by iterate_json_values().

{
    IterateJsonStringValuesState *_state = (IterateJsonStringValuesState *) state;

    switch (tokentype)
    {
        case JSON_TOKEN_STRING:
            if (_state->flags & jtiString)
                _state->action(_state->action_state, token, strlen(token));
            break;
        case JSON_TOKEN_NUMBER:
            if (_state->flags & jtiNumeric)
                _state->action(_state->action_state, token, strlen(token));
            break;
        case JSON_TOKEN_TRUE:
        case JSON_TOKEN_FALSE:
            if (_state->flags & jtiBool)
                _state->action(_state->action_state, token, strlen(token));
            break;
        default:
            /* do not call callback for any other token */
            break;
    }
}

IteratorConcat()

static JsonbValue * IteratorConcat ( JsonbIterator **  it1, JsonbIterator **  it2, JsonbParseState **  state  )

static

Definition at line 4551 of file jsonfuncs.c.

References Assert, ereport, errcode(), errmsg(), ERROR, JsonbIteratorNext(), pushJsonbValue(), WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, and WJB_END_OBJECT.

Referenced by jsonb_concat().

{
    JsonbValue  v1,
                v2,
               *res = NULL;
    JsonbIteratorToken r1,
                r2,
                rk1,
                rk2;

    r1 = rk1 = JsonbIteratorNext(it1, &v1, false);
    r2 = rk2 = JsonbIteratorNext(it2, &v2, false);

    /*
     * Both elements are objects.
     */
    if (rk1 == WJB_BEGIN_OBJECT && rk2 == WJB_BEGIN_OBJECT)
    {
        /*
         * Append the all tokens from v1 to res, except last WJB_END_OBJECT
         * (because res will not be finished yet).
         */
        pushJsonbValue(state, r1, NULL);
        while ((r1 = JsonbIteratorNext(it1, &v1, true)) != WJB_END_OBJECT)
            pushJsonbValue(state, r1, &v1);

        /*
         * Append the all tokens from v2 to res, include last WJB_END_OBJECT
         * (the concatenation will be completed).
         */
        while ((r2 = JsonbIteratorNext(it2, &v2, true)) != WJB_DONE)
            res = pushJsonbValue(state, r2, r2 != WJB_END_OBJECT ? &v2 : NULL);
    }

    /*
     * Both elements are arrays (either can be scalar).
     */
    else if (rk1 == WJB_BEGIN_ARRAY && rk2 == WJB_BEGIN_ARRAY)
    {
        pushJsonbValue(state, r1, NULL);

        while ((r1 = JsonbIteratorNext(it1, &v1, true)) != WJB_END_ARRAY)
        {
            Assert(r1 == WJB_ELEM);
            pushJsonbValue(state, r1, &v1);
        }

        while ((r2 = JsonbIteratorNext(it2, &v2, true)) != WJB_END_ARRAY)
        {
            Assert(r2 == WJB_ELEM);
            pushJsonbValue(state, WJB_ELEM, &v2);
        }

        res = pushJsonbValue(state, WJB_END_ARRAY, NULL /* signal to sort */ );
    }
    /* have we got array || object or object || array? */
    else if (((rk1 == WJB_BEGIN_ARRAY && !(*it1)->isScalar) && rk2 == WJB_BEGIN_OBJECT) ||
             (rk1 == WJB_BEGIN_OBJECT && (rk2 == WJB_BEGIN_ARRAY && !(*it2)->isScalar)))
    {

        JsonbIterator **it_array = rk1 == WJB_BEGIN_ARRAY ? it1 : it2;
        JsonbIterator **it_object = rk1 == WJB_BEGIN_OBJECT ? it1 : it2;

        bool        prepend = (rk1 == WJB_BEGIN_OBJECT);

        pushJsonbValue(state, WJB_BEGIN_ARRAY, NULL);

        if (prepend)
        {
            pushJsonbValue(state, WJB_BEGIN_OBJECT, NULL);
            while ((r1 = JsonbIteratorNext(it_object, &v1, true)) != WJB_DONE)
                pushJsonbValue(state, r1, r1 != WJB_END_OBJECT ? &v1 : NULL);

            while ((r2 = JsonbIteratorNext(it_array, &v2, true)) != WJB_DONE)
                res = pushJsonbValue(state, r2, r2 != WJB_END_ARRAY ? &v2 : NULL);
        }
        else
        {
            while ((r1 = JsonbIteratorNext(it_array, &v1, true)) != WJB_END_ARRAY)
                pushJsonbValue(state, r1, &v1);

            pushJsonbValue(state, WJB_BEGIN_OBJECT, NULL);
            while ((r2 = JsonbIteratorNext(it_object, &v2, true)) != WJB_DONE)
                pushJsonbValue(state, r2, r2 != WJB_END_OBJECT ? &v2 : NULL);

            res = pushJsonbValue(state, WJB_END_ARRAY, NULL);
        }
    }
    else
    {
        /*
         * This must be scalar || object or object || scalar, as that's all
         * that's left. Both of these make no sense, so error out.
         */
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid concatenation of jsonb objects")));
    }

    return res;
}

JsObjectGetField()

static bool JsObjectGetField ( JsObject *  obj, char *  field, JsValue *  jsv  )

static

Definition at line 3071 of file jsonfuncs.c.

References findJsonbValueFromContainerLen(), HASH_FIND, hash_search(), JsValue::is_json, JsObject::is_json, JB_FOBJECT, JsValue::json, JsObject::json_hash, JSON_TOKEN_NULL, JsValue::jsonb, JsObject::jsonb_cont, JsonHashEntry::type, JsonHashEntry::val, JsValue::val, and JsObject::val.

Referenced by populate_record().

{
    jsv->is_json = obj->is_json;

    if (jsv->is_json)
    {
        JsonHashEntry *hashentry = hash_search(obj->val.json_hash, field,
                                               HASH_FIND, NULL);

        jsv->val.json.type = hashentry ? hashentry->type : JSON_TOKEN_NULL;
        jsv->val.json.str = jsv->val.json.type == JSON_TOKEN_NULL ? NULL :
            hashentry->val;
        jsv->val.json.len = jsv->val.json.str ? -1 : 0; /* null-terminated */

        return hashentry != NULL;
    }
    else
    {
        jsv->val.jsonb = !obj->val.jsonb_cont ? NULL :
            findJsonbValueFromContainerLen(obj->val.jsonb_cont, JB_FOBJECT,
                                           field, strlen(field));

        return jsv->val.jsonb != NULL;
    }
}

json_array_element()

Datum json_array_element

(

PG_FUNCTION_ARGS

)

Definition at line 803 of file jsonfuncs.c.

References element(), get_worker(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and OkeysState::result.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    int         element = PG_GETARG_INT32(1);
    text       *result;

    result = get_worker(json, NULL, &element, 1, false);

    if (result != NULL)
        PG_RETURN_TEXT_P(result);
    else
        PG_RETURN_NULL();
}

json_array_element_text()

Datum json_array_element_text

(

PG_FUNCTION_ARGS

)

Definition at line 846 of file jsonfuncs.c.

References element(), get_worker(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and OkeysState::result.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    int         element = PG_GETARG_INT32(1);
    text       *result;

    result = get_worker(json, NULL, &element, 1, true);

    if (result != NULL)
        PG_RETURN_TEXT_P(result);
    else
        PG_RETURN_NULL();
}

json_array_elements()

Datum json_array_elements

(

PG_FUNCTION_ARGS

)

Definition at line 2113 of file jsonfuncs.c.

References elements_worker().

{
    return elements_worker(fcinfo, "json_array_elements", false);
}

json_array_elements_text()

Datum json_array_elements_text

(

PG_FUNCTION_ARGS

)

Definition at line 2119 of file jsonfuncs.c.

References elements_worker().

{
    return elements_worker(fcinfo, "json_array_elements_text", true);
}

json_array_length()

Datum json_array_length

(

PG_FUNCTION_ARGS

)

Definition at line 1556 of file jsonfuncs.c.

References alen_array_element_start(), alen_object_start(), alen_scalar(), JsonSemAction::array_element_start, AlenState::count, OkeysState::lex, AlenState::lex, makeJsonLexContext(), JsonSemAction::object_start, palloc0(), PG_GETARG_TEXT_PP, pg_parse_json(), PG_RETURN_INT32, JsonSemAction::scalar, and JsonSemAction::semstate.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    AlenState  *state;
    JsonLexContext *lex;
    JsonSemAction *sem;

    lex = makeJsonLexContext(json, false);
    state = palloc0(sizeof(AlenState));
    sem = palloc0(sizeof(JsonSemAction));

    /* palloc0 does this for us */
#if 0
    state->count = 0;
#endif
    state->lex = lex;

    sem->semstate = (void *) state;
    sem->object_start = alen_object_start;
    sem->scalar = alen_scalar;
    sem->array_element_start = alen_array_element_start;

    pg_parse_json(lex, sem);

    PG_RETURN_INT32(state->count);
}

json_each()

Datum json_each

(

PG_FUNCTION_ARGS

)

Definition at line 1650 of file jsonfuncs.c.

References each_worker().

{
    return each_worker(fcinfo, false);
}

json_each_text()

Datum json_each_text

(

PG_FUNCTION_ARGS

)

Definition at line 1662 of file jsonfuncs.c.

References each_worker().

{
    return each_worker(fcinfo, true);
}

json_extract_path()

Datum json_extract_path

(

PG_FUNCTION_ARGS

)

Definition at line 920 of file jsonfuncs.c.

References get_path_all().

{
    return get_path_all(fcinfo, false);
}

json_extract_path_text()

Datum json_extract_path_text

(

PG_FUNCTION_ARGS

)

Definition at line 926 of file jsonfuncs.c.

References get_path_all().

{
    return get_path_all(fcinfo, true);
}

json_object_field()

Datum json_object_field

(

PG_FUNCTION_ARGS

)

Definition at line 700 of file jsonfuncs.c.

References get_worker(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, OkeysState::result, and text_to_cstring().

{
    text       *json = PG_GETARG_TEXT_PP(0);
    text       *fname = PG_GETARG_TEXT_PP(1);
    char       *fnamestr = text_to_cstring(fname);
    text       *result;

    result = get_worker(json, &fnamestr, NULL, 1, false);

    if (result != NULL)
        PG_RETURN_TEXT_P(result);
    else
        PG_RETURN_NULL();
}

json_object_field_text()

Datum json_object_field_text

(

PG_FUNCTION_ARGS

)

Definition at line 736 of file jsonfuncs.c.

References get_worker(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, OkeysState::result, and text_to_cstring().

{
    text       *json = PG_GETARG_TEXT_PP(0);
    text       *fname = PG_GETARG_TEXT_PP(1);
    char       *fnamestr = text_to_cstring(fname);
    text       *result;

    result = get_worker(json, &fnamestr, NULL, 1, true);

    if (result != NULL)
        PG_RETURN_TEXT_P(result);
    else
        PG_RETURN_NULL();
}

json_object_keys()

Datum json_object_keys

(

PG_FUNCTION_ARGS

)

Definition at line 583 of file jsonfuncs.c.

References JsonSemAction::array_start, CStringGetTextDatum, StringInfoData::data, i, OkeysState::lex, makeJsonLexContext(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, JsonSemAction::object_field_start, okeys_array_start(), okeys_object_field_start(), okeys_scalar(), palloc(), palloc0(), pfree(), PG_GETARG_TEXT_PP, pg_parse_json(), OkeysState::result, OkeysState::result_count, OkeysState::result_size, JsonSemAction::scalar, JsonSemAction::semstate, OkeysState::sent_count, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, JsonLexContext::strval, and FuncCallContext::user_fctx.

{
    FuncCallContext *funcctx;
    OkeysState *state;
    int         i;

    if (SRF_IS_FIRSTCALL())
    {
        text       *json = PG_GETARG_TEXT_PP(0);
        JsonLexContext *lex = makeJsonLexContext(json, true);
        JsonSemAction *sem;
        MemoryContext oldcontext;

        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

        state = palloc(sizeof(OkeysState));
        sem = palloc0(sizeof(JsonSemAction));

        state->lex = lex;
        state->result_size = 256;
        state->result_count = 0;
        state->sent_count = 0;
        state->result = palloc(256 * sizeof(char *));

        sem->semstate = (void *) state;
        sem->array_start = okeys_array_start;
        sem->scalar = okeys_scalar;
        sem->object_field_start = okeys_object_field_start;
        /* remainder are all NULL, courtesy of palloc0 above */

        pg_parse_json(lex, sem);
        /* keys are now in state->result */

        pfree(lex->strval->data);
        pfree(lex->strval);
        pfree(lex);
        pfree(sem);

        MemoryContextSwitchTo(oldcontext);
        funcctx->user_fctx = (void *) state;
    }

    funcctx = SRF_PERCALL_SETUP();
    state = (OkeysState *) funcctx->user_fctx;

    if (state->sent_count < state->result_count)
    {
        char       *nxt = state->result[state->sent_count++];

        SRF_RETURN_NEXT(funcctx, CStringGetTextDatum(nxt));
    }

    /* cleanup to reduce or eliminate memory leaks */
    for (i = 0; i < state->result_count; i++)
        pfree(state->result[i]);
    pfree(state->result);
    pfree(state);

    SRF_RETURN_DONE(funcctx);
}

json_populate_record()

Datum json_populate_record

(

PG_FUNCTION_ARGS

)

Definition at line 2309 of file jsonfuncs.c.

References populate_record_worker().

{
    return populate_record_worker(fcinfo, "json_populate_record", true);
}

json_populate_recordset()

Datum json_populate_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3502 of file jsonfuncs.c.

References populate_recordset_worker().

{
    return populate_recordset_worker(fcinfo, "json_populate_recordset", true);
}

json_strip_nulls()

Datum json_strip_nulls

(

PG_FUNCTION_ARGS

)

Definition at line 4005 of file jsonfuncs.c.

References JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, cstring_to_text_with_len(), StringInfoData::data, StringInfoData::len, OkeysState::lex, StripnullState::lex, makeJsonLexContext(), makeStringInfo(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc0(), PG_GETARG_TEXT_PP, pg_parse_json(), PG_RETURN_TEXT_P, JsonSemAction::scalar, JsonSemAction::semstate, StripnullState::skip_next_null, sn_array_element_start(), sn_array_end(), sn_array_start(), sn_object_end(), sn_object_field_start(), sn_object_start(), sn_scalar(), and StripnullState::strval.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    StripnullState *state;
    JsonLexContext *lex;
    JsonSemAction *sem;

    lex = makeJsonLexContext(json, true);
    state = palloc0(sizeof(StripnullState));
    sem = palloc0(sizeof(JsonSemAction));

    state->strval = makeStringInfo();
    state->skip_next_null = false;
    state->lex = lex;

    sem->semstate = (void *) state;
    sem->object_start = sn_object_start;
    sem->object_end = sn_object_end;
    sem->array_start = sn_array_start;
    sem->array_end = sn_array_end;
    sem->scalar = sn_scalar;
    sem->array_element_start = sn_array_element_start;
    sem->object_field_start = sn_object_field_start;

    pg_parse_json(lex, sem);

    PG_RETURN_TEXT_P(cstring_to_text_with_len(state->strval->data,
                                              state->strval->len));

}

json_to_record()

Datum json_to_record

(

PG_FUNCTION_ARGS

)

Definition at line 2315 of file jsonfuncs.c.

References populate_record_worker().

{
    return populate_record_worker(fcinfo, "json_to_record", false);
}

json_to_recordset()

Datum json_to_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3508 of file jsonfuncs.c.

References populate_recordset_worker().

{
    return populate_recordset_worker(fcinfo, "json_to_recordset", false);
}

jsonb_array_element()

Datum jsonb_array_element

(

PG_FUNCTION_ARGS

)

Definition at line 818 of file jsonfuncs.c.

References element(), getIthJsonbValueFromContainer(), JB_ROOT_COUNT, JB_ROOT_IS_ARRAY, JsonbValueToJsonb(), PG_GETARG_INT32, PG_GETARG_JSONB_P, PG_RETURN_JSONB_P, PG_RETURN_NULL, and Jsonb::root.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    int         element = PG_GETARG_INT32(1);
    JsonbValue *v;

    if (!JB_ROOT_IS_ARRAY(jb))
        PG_RETURN_NULL();

    /* Handle negative subscript */
    if (element < 0)
    {
        uint32      nelements = JB_ROOT_COUNT(jb);

        if (-element > nelements)
            PG_RETURN_NULL();
        else
            element += nelements;
    }

    v = getIthJsonbValueFromContainer(&jb->root, element);
    if (v != NULL)
        PG_RETURN_JSONB_P(JsonbValueToJsonb(v));

    PG_RETURN_NULL();
}

jsonb_array_element_text()

Datum jsonb_array_element_text

(

PG_FUNCTION_ARGS

)

Definition at line 861 of file jsonfuncs.c.

References cstring_to_text(), cstring_to_text_with_len(), StringInfoData::data, DatumGetCString, DirectFunctionCall1, element(), elog, ERROR, getIthJsonbValueFromContainer(), JB_ROOT_COUNT, JB_ROOT_IS_ARRAY, jbvBinary, jbvBool, jbvNull, jbvNumeric, jbvString, JsonbToCString(), StringInfoData::len, makeStringInfo(), numeric_out(), PG_GETARG_INT32, PG_GETARG_JSONB_P, PG_RETURN_NULL, PG_RETURN_TEXT_P, PointerGetDatum, OkeysState::result, Jsonb::root, JsonbValue::type, and JsonbValue::val.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    int         element = PG_GETARG_INT32(1);
    JsonbValue *v;

    if (!JB_ROOT_IS_ARRAY(jb))
        PG_RETURN_NULL();

    /* Handle negative subscript */
    if (element < 0)
    {
        uint32      nelements = JB_ROOT_COUNT(jb);

        if (-element > nelements)
            PG_RETURN_NULL();
        else
            element += nelements;
    }

    v = getIthJsonbValueFromContainer(&jb->root, element);
    if (v != NULL)
    {
        text       *result = NULL;

        switch (v->type)
        {
            case jbvNull:
                break;
            case jbvBool:
                result = cstring_to_text(v->val.boolean ? "true" : "false");
                break;
            case jbvString:
                result = cstring_to_text_with_len(v->val.string.val, v->val.string.len);
                break;
            case jbvNumeric:
                result = cstring_to_text(DatumGetCString(DirectFunctionCall1(numeric_out,
                                                                             PointerGetDatum(v->val.numeric))));
                break;
            case jbvBinary:
                {
                    StringInfo  jtext = makeStringInfo();

                    (void) JsonbToCString(jtext, v->val.binary.data, -1);
                    result = cstring_to_text_with_len(jtext->data, jtext->len);
                }
                break;
            default:
                elog(ERROR, "unrecognized jsonb type: %d", (int) v->type);
        }

        if (result)
            PG_RETURN_TEXT_P(result);
    }

    PG_RETURN_NULL();
}

jsonb_array_elements()

Datum jsonb_array_elements

(

PG_FUNCTION_ARGS

)

Definition at line 1977 of file jsonfuncs.c.

References elements_worker_jsonb().

{
    return elements_worker_jsonb(fcinfo, "jsonb_array_elements", false);
}

jsonb_array_elements_text()

Datum jsonb_array_elements_text

(

PG_FUNCTION_ARGS

)

Definition at line 1983 of file jsonfuncs.c.

References elements_worker_jsonb().

{
    return elements_worker_jsonb(fcinfo, "jsonb_array_elements_text", true);
}

jsonb_array_length()

Datum jsonb_array_length

(

PG_FUNCTION_ARGS

)

Definition at line 1584 of file jsonfuncs.c.

References ereport, errcode(), errmsg(), ERROR, JB_ROOT_COUNT, JB_ROOT_IS_ARRAY, JB_ROOT_IS_SCALAR, PG_GETARG_JSONB_P, and PG_RETURN_INT32.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);

    if (JB_ROOT_IS_SCALAR(jb))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot get array length of a scalar")));
    else if (!JB_ROOT_IS_ARRAY(jb))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot get array length of a non-array")));

    PG_RETURN_INT32(JB_ROOT_COUNT(jb));
}

jsonb_concat()

Datum jsonb_concat

(

PG_FUNCTION_ARGS

)

Definition at line 4166 of file jsonfuncs.c.

References Assert, IteratorConcat(), JB_ROOT_COUNT, JB_ROOT_IS_OBJECT, JB_ROOT_IS_SCALAR, JsonbIteratorInit(), JsonbValueToJsonb(), PG_GETARG_JSONB_P, PG_RETURN_JSONB_P, and Jsonb::root.

{
    Jsonb      *jb1 = PG_GETARG_JSONB_P(0);
    Jsonb      *jb2 = PG_GETARG_JSONB_P(1);
    JsonbParseState *state = NULL;
    JsonbValue *res;
    JsonbIterator *it1,
               *it2;

    /*
     * If one of the jsonb is empty, just return the other if it's not scalar
     * and both are of the same kind.  If it's a scalar or they are of
     * different kinds we need to perform the concatenation even if one is
     * empty.
     */
    if (JB_ROOT_IS_OBJECT(jb1) == JB_ROOT_IS_OBJECT(jb2))
    {
        if (JB_ROOT_COUNT(jb1) == 0 && !JB_ROOT_IS_SCALAR(jb2))
            PG_RETURN_JSONB_P(jb2);
        else if (JB_ROOT_COUNT(jb2) == 0 && !JB_ROOT_IS_SCALAR(jb1))
            PG_RETURN_JSONB_P(jb1);
    }

    it1 = JsonbIteratorInit(&jb1->root);
    it2 = JsonbIteratorInit(&jb2->root);

    res = IteratorConcat(&it1, &it2, &state);

    Assert(res != NULL);

    PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}

jsonb_delete()

Datum jsonb_delete

(

PG_FUNCTION_ARGS

)

Definition at line 4207 of file jsonfuncs.c.

References Assert, ereport, errcode(), errmsg(), ERROR, JB_ROOT_COUNT, JB_ROOT_IS_SCALAR, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), PG_GETARG_JSONB_P, PG_GETARG_TEXT_PP, PG_RETURN_JSONB_P, pushJsonbValue(), Jsonb::root, JsonbValue::type, JsonbValue::val, VARDATA_ANY, VARSIZE_ANY_EXHDR, WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, and WJB_KEY.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    text       *key = PG_GETARG_TEXT_PP(1);
    char       *keyptr = VARDATA_ANY(key);
    int         keylen = VARSIZE_ANY_EXHDR(key);
    JsonbParseState *state = NULL;
    JsonbIterator *it;
    JsonbValue  v,
               *res = NULL;
    bool        skipNested = false;
    JsonbIteratorToken r;

    if (JB_ROOT_IS_SCALAR(in))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot delete from scalar")));

    if (JB_ROOT_COUNT(in) == 0)
        PG_RETURN_JSONB_P(in);

    it = JsonbIteratorInit(&in->root);

    while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
    {
        skipNested = true;

        if ((r == WJB_ELEM || r == WJB_KEY) &&
            (v.type == jbvString && keylen == v.val.string.len &&
             memcmp(keyptr, v.val.string.val, keylen) == 0))
        {
            /* skip corresponding value as well */
            if (r == WJB_KEY)
                (void) JsonbIteratorNext(&it, &v, true);

            continue;
        }

        res = pushJsonbValue(&state, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
    }

    Assert(res != NULL);

    PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}

jsonb_delete_array()

Datum jsonb_delete_array

(

PG_FUNCTION_ARGS

)

Definition at line 4260 of file jsonfuncs.c.

References ARR_NDIM, Assert, deconstruct_array(), ereport, errcode(), errmsg(), ERROR, i, JB_ROOT_COUNT, JB_ROOT_IS_SCALAR, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_JSONB_P, PG_RETURN_JSONB_P, pushJsonbValue(), Jsonb::root, JsonbValue::type, JsonbValue::val, VARDATA_ANY, VARSIZE_ANY_EXHDR, WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, and WJB_KEY.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    ArrayType  *keys = PG_GETARG_ARRAYTYPE_P(1);
    Datum      *keys_elems;
    bool       *keys_nulls;
    int         keys_len;
    JsonbParseState *state = NULL;
    JsonbIterator *it;
    JsonbValue  v,
               *res = NULL;
    bool        skipNested = false;
    JsonbIteratorToken r;

    if (ARR_NDIM(keys) > 1)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("wrong number of array subscripts")));

    if (JB_ROOT_IS_SCALAR(in))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot delete from scalar")));

    if (JB_ROOT_COUNT(in) == 0)
        PG_RETURN_JSONB_P(in);

    deconstruct_array(keys, TEXTOID, -1, false, 'i',
                      &keys_elems, &keys_nulls, &keys_len);

    if (keys_len == 0)
        PG_RETURN_JSONB_P(in);

    it = JsonbIteratorInit(&in->root);

    while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
    {
        skipNested = true;

        if ((r == WJB_ELEM || r == WJB_KEY) && v.type == jbvString)
        {
            int         i;
            bool        found = false;

            for (i = 0; i < keys_len; i++)
            {
                char       *keyptr;
                int         keylen;

                if (keys_nulls[i])
                    continue;

                keyptr = VARDATA_ANY(keys_elems[i]);
                keylen = VARSIZE_ANY_EXHDR(keys_elems[i]);
                if (keylen == v.val.string.len &&
                    memcmp(keyptr, v.val.string.val, keylen) == 0)
                {
                    found = true;
                    break;
                }
            }
            if (found)
            {
                /* skip corresponding value as well */
                if (r == WJB_KEY)
                    (void) JsonbIteratorNext(&it, &v, true);

                continue;
            }
        }

        res = pushJsonbValue(&state, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
    }

    Assert(res != NULL);

    PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}

jsonb_delete_idx()

Datum jsonb_delete_idx

(

PG_FUNCTION_ARGS

)

Definition at line 4347 of file jsonfuncs.c.

References Assert, ereport, errcode(), errmsg(), ERROR, i, idx(), JB_ROOT_COUNT, JB_ROOT_IS_OBJECT, JB_ROOT_IS_SCALAR, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), PG_GETARG_INT32, PG_GETARG_JSONB_P, PG_RETURN_JSONB_P, pushJsonbValue(), Jsonb::root, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_DONE, and WJB_ELEM.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    int         idx = PG_GETARG_INT32(1);
    JsonbParseState *state = NULL;
    JsonbIterator *it;
    uint32      i = 0,
                n;
    JsonbValue  v,
               *res = NULL;
    JsonbIteratorToken r;

    if (JB_ROOT_IS_SCALAR(in))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot delete from scalar")));

    if (JB_ROOT_IS_OBJECT(in))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot delete from object using integer index")));

    if (JB_ROOT_COUNT(in) == 0)
        PG_RETURN_JSONB_P(in);

    it = JsonbIteratorInit(&in->root);

    r = JsonbIteratorNext(&it, &v, false);
    Assert(r == WJB_BEGIN_ARRAY);
    n = v.val.array.nElems;

    if (idx < 0)
    {
        if (-idx > n)
            idx = n;
        else
            idx = n + idx;
    }

    if (idx >= n)
        PG_RETURN_JSONB_P(in);

    pushJsonbValue(&state, r, NULL);

    while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
    {
        if (r == WJB_ELEM)
        {
            if (i++ == idx)
                continue;
        }

        res = pushJsonbValue(&state, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
    }

    Assert(res != NULL);

    PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}

jsonb_delete_path()

Datum jsonb_delete_path

(

PG_FUNCTION_ARGS

)

Definition at line 4459 of file jsonfuncs.c.

References ARR_NDIM, Assert, deconstruct_array(), ereport, errcode(), errmsg(), ERROR, JB_PATH_DELETE, JB_ROOT_COUNT, JB_ROOT_IS_SCALAR, JsonbIteratorInit(), JsonbValueToJsonb(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_JSONB_P, PG_RETURN_JSONB_P, Jsonb::root, and setPath().

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    ArrayType  *path = PG_GETARG_ARRAYTYPE_P(1);
    JsonbValue *res = NULL;
    Datum      *path_elems;
    bool       *path_nulls;
    int         path_len;
    JsonbIterator *it;
    JsonbParseState *st = NULL;

    if (ARR_NDIM(path) > 1)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("wrong number of array subscripts")));

    if (JB_ROOT_IS_SCALAR(in))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot delete path in scalar")));

    if (JB_ROOT_COUNT(in) == 0)
        PG_RETURN_JSONB_P(in);

    deconstruct_array(path, TEXTOID, -1, false, 'i',
                      &path_elems, &path_nulls, &path_len);

    if (path_len == 0)
        PG_RETURN_JSONB_P(in);

    it = JsonbIteratorInit(&in->root);

    res = setPath(&it, path_elems, path_nulls, path_len, &st,
                  0, NULL, JB_PATH_DELETE);

    Assert(res != NULL);

    PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}

jsonb_each()

Datum jsonb_each

(

PG_FUNCTION_ARGS

)

Definition at line 1656 of file jsonfuncs.c.

References each_worker_jsonb().

{
    return each_worker_jsonb(fcinfo, "jsonb_each", false);
}

jsonb_each_text()

Datum jsonb_each_text

(

PG_FUNCTION_ARGS

)

Definition at line 1668 of file jsonfuncs.c.

References each_worker_jsonb().

{
    return each_worker_jsonb(fcinfo, "jsonb_each_text", true);
}

jsonb_extract_path()

Datum jsonb_extract_path

(

PG_FUNCTION_ARGS

)

Definition at line 1376 of file jsonfuncs.c.

References get_jsonb_path_all().

{
    return get_jsonb_path_all(fcinfo, false);
}

jsonb_extract_path_text()

Datum jsonb_extract_path_text

(

PG_FUNCTION_ARGS

)

Definition at line 1382 of file jsonfuncs.c.

References get_jsonb_path_all().

{
    return get_jsonb_path_all(fcinfo, true);
}

jsonb_insert()

Datum jsonb_insert

(