jsonfuncs.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/htup_details.h"
#include "catalog/pg_type.h"
#include "common/jsonapi.h"
#include "common/string.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/fmgroids.h"
#include "utils/hsearch.h"
#include "utils/json.h"
#include "utils/jsonb.h"
#include "utils/jsonfuncs.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	PopulateRecordCache
struct	PopulateRecordsetState
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	JB_PATH_FILL_GAPS   0x0020
#define	JB_PATH_CONSISTENT_POSITION   0x0040
#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 PopulateRecordCache	PopulateRecordCache
typedef struct PopulateRecordsetState	PopulateRecordsetState
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 int	report_json_context (JsonLexContext *lex)
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 text *	JsonbValueAsText (JsonbValue *v)
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 is_json, bool have_record_arg)
static Datum	populate_record_worker (FunctionCallInfo fcinfo, const char *funcname, bool is_json, bool have_record_arg)
static HeapTupleHeader	populate_record (TupleDesc tupdesc, RecordIOData **record_p, HeapTupleHeader defaultval, MemoryContext mcxt, JsObject *obj)
static void	get_record_type_from_argument (FunctionCallInfo fcinfo, const char *funcname, PopulateRecordCache *cache)
static void	get_record_type_from_query (FunctionCallInfo fcinfo, const char *funcname, PopulateRecordCache *cache)
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 *	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, JsonbValue *newval, int op_type)
static void	setPathObject (JsonbIterator **it, Datum *path_elems, bool *path_nulls, int path_len, JsonbParseState **st, int level, JsonbValue *newval, uint32 npairs, int op_type)
static void	setPathArray (JsonbIterator **it, Datum *path_elems, bool *path_nulls, int path_len, JsonbParseState **st, int level, JsonbValue *newval, uint32 nelems, int op_type)
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)
void	pg_parse_json_or_ereport (JsonLexContext *lex, JsonSemAction *sem)
JsonLexContext *	makeJsonLexContext (text *json, bool need_escapes)
Datum	jsonb_object_keys (PG_FUNCTION_ARGS)
void	json_ereport_error (JsonParseErrorType error, JsonLexContext *lex)
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	jsonb_get_element (Jsonb *jb, Datum *path, int npath, bool *isnull, bool as_text)
Datum	jsonb_set_element (Jsonb *jb, Datum *path, int path_len, JsonbValue *newval)
static void	push_null_elements (JsonbParseState **ps, int num)
static void	push_path (JsonbParseState **st, int level, Datum *path_elems, bool *path_nulls, int path_len, JsonbValue *newval)
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_set_lax (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_CONSISTENT_POSITION

#define JB_PATH_CONSISTENT_POSITION   0x0040

Definition at line 49 of file jsonfuncs.c.

Referenced by jsonb_set_element(), and setPathArray().

JB_PATH_CREATE

#define JB_PATH_CREATE   0x0001

Definition at line 41 of file jsonfuncs.c.

Referenced by jsonb_set(), jsonb_set_element(), 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 46 of file jsonfuncs.c.

Referenced by setPathArray(), and setPathObject().

JB_PATH_DELETE

#define JB_PATH_DELETE   0x0002

Definition at line 42 of file jsonfuncs.c.

Referenced by jsonb_delete_path(), and setPathObject().

JB_PATH_FILL_GAPS

#define JB_PATH_FILL_GAPS   0x0020

Definition at line 48 of file jsonfuncs.c.

Referenced by jsonb_set_element(), setPath(), setPathArray(), and setPathObject().

JB_PATH_INSERT_AFTER

#define JB_PATH_INSERT_AFTER   0x0010

Definition at line 45 of file jsonfuncs.c.

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

JB_PATH_INSERT_BEFORE

#define JB_PATH_INSERT_BEFORE   0x0008

Definition at line 44 of file jsonfuncs.c.

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

JB_PATH_REPLACE

#define JB_PATH_REPLACE   0x0004

Definition at line 43 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 330 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 324 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 315 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 320 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 159 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

PopulateRecordsetState

typedef struct PopulateRecordsetState PopulateRecordsetState

RecordIOData

typedef struct RecordIOData RecordIOData

Definition at line 160 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 196 of file jsonfuncs.c.

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

Function Documentation

alen_array_element_start()

static void alen_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 1864 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 1840 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 1852 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 3251 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 2156 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 2110 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 2090 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 2168 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 2026 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_or_ereport(), PG_RETURN_NULL, FunctionCallInfoBaseData::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_or_ereport(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 1908 of file jsonfuncs.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ReturnSetInfo::allowedModes, Assert, BlessTupleDesc(), CreateTupleDescCopy(), cstring_to_text_with_len(), CurrentMemoryContext, 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, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueAsText(), JsonbValueToJsonb(), sort-test::key, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), PG_GETARG_JSONB_P, PG_RETURN_NULL, PointerGetDatum, FunctionCallInfoBaseData::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
                    values[1] = PointerGetDatum(JsonbValueAsText(&v));
            }
            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 2408 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 2388 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 2452 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 2465 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 2322 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_or_ereport(), PG_RETURN_NULL, FunctionCallInfoBaseData::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_or_ereport(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 2204 of file jsonfuncs.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ReturnSetInfo::allowedModes, BlessTupleDesc(), CreateTupleDescCopy(), CurrentMemoryContext, 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, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueAsText(), JsonbValueToJsonb(), MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), PG_GETARG_JSONB_P, PG_RETURN_NULL, PointerGetDatum, FunctionCallInfoBaseData::resultinfo, ReturnSetInfo::returnMode, Jsonb::root, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Random, tuplestore_begin_heap(), tuplestore_puttuple(), JsonbValue::type, 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)
            {
                if (v.type == jbvNull)
                {
                    /* a json null is an sql null in text mode */
                    nulls[0] = true;
                    values[0] = (Datum) NULL;
                }
                else
                    values[0] = PointerGetDatum(JsonbValueAsText(&v));
            }
            else
            {
                /* Not in text mode, just return the Jsonb */
                Jsonb      *val = JsonbValueToJsonb(&v);

                values[0] = 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();
}

get_array_element_end()

static void get_array_element_end ( void *  state, bool  isnull  )

static

Definition at line 1344 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 1298 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 1282 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 1244 of file jsonfuncs.c.

References GetState::array_cur_index, error(), json_count_array_elements(), json_ereport_error(), JSON_SUCCESS, 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 */
            JsonParseErrorType error;
            int         nelements;

            error = json_count_array_elements(_state->lex, &nelements);
            if (error != JSON_SUCCESS)
                json_ereport_error(error, _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 3576 of file jsonfuncs.c.

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

Referenced by JsValueToJsObject().

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

    ctl.keysize = NAMEDATALEN;
    ctl.entrysize = sizeof(JsonHashEntry);
    ctl.hcxt = CurrentMemoryContext;
    tab = hash_create("json object hashtable",
                      100,
                      &ctl,
                      HASH_ELEM | HASH_STRINGS | 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_or_ereport(lex, sem);

    return tab;
}

get_jsonb_path_all()

static Datum get_jsonb_path_all ( FunctionCallInfo  fcinfo, bool  as_text  )

static

Definition at line 1439 of file jsonfuncs.c.

References array_contains_nulls(), deconstruct_array(), jsonb_get_element(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_JSONB_P, PG_RETURN_DATUM, and PG_RETURN_NULL.

Referenced by jsonb_extract_path(), and jsonb_extract_path_text().

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    ArrayType  *path = PG_GETARG_ARRAYTYPE_P(1);
    Datum      *pathtext;
    bool       *pathnulls;
    bool        isnull;
    int         npath;
    Datum       res;

    /*
     * 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, TYPALIGN_INT,
                      &pathtext, &pathnulls, &npath);

    res = jsonb_get_element(jb, pathtext, npath, &isnull, as_text);

    if (isnull)
        PG_RETURN_NULL();
    else
        PG_RETURN_DATUM(res);
}

get_object_end()

static void get_object_end ( void *  state )

static

Definition at line 1134 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 1195 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 1150 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 1117 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 981 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, strtoint(), 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, TYPALIGN_INT,
                      &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')
        {
            int         ind;
            char       *endptr;

            errno = 0;
            ind = strtoint(tpath[i], &endptr, 10);
            if (endptr == tpath[i] || *endptr != '\0' || errno != 0)
                ipath[i] = INT_MIN;
            else
                ipath[i] = ind;
        }
        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_record_type_from_argument()

static void get_record_type_from_argument ( FunctionCallInfo  fcinfo, const char *  funcname, PopulateRecordCache *  cache  )

static

Definition at line 3408 of file jsonfuncs.c.

References PopulateRecordCache::argtype, PopulateRecordCache::c, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, PopulateRecordCache::fn_mcxt, get_fn_expr_argtype(), prepare_column_cache(), ColumnIOData::typcat, TYPECAT_COMPOSITE, and TYPECAT_COMPOSITE_DOMAIN.

Referenced by populate_record_worker(), and populate_recordset_worker().

{
    cache->argtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
    prepare_column_cache(&cache->c,
                         cache->argtype, -1,
                         cache->fn_mcxt, false);
    if (cache->c.typcat != TYPECAT_COMPOSITE &&
        cache->c.typcat != TYPECAT_COMPOSITE_DOMAIN)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
        /* translator: %s is a function name, eg json_to_record */
                 errmsg("first argument of %s must be a row type",
                        funcname)));
}

get_record_type_from_query()

static void get_record_type_from_query ( FunctionCallInfo  fcinfo, const char *  funcname, PopulateRecordCache *  cache  )

static

Definition at line 3434 of file jsonfuncs.c.

References PopulateRecordCache::argtype, Assert, CompositeIOData::base_typid, CompositeIOData::base_typmod, PopulateRecordCache::c, ColumnIOData::composite, CreateTupleDescCopy(), ereport, errcode(), errhint(), errmsg(), ERROR, PopulateRecordCache::fn_mcxt, FreeTupleDesc(), get_call_result_type(), ColumnIOData::io, MemoryContextSwitchTo(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, CompositeIOData::tupdesc, and TYPEFUNC_COMPOSITE.

Referenced by populate_record_worker(), and populate_recordset_worker().

{
    TupleDesc   tupdesc;
    MemoryContext old_cxt;

    if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /* translator: %s is a function name, eg json_to_record */
                 errmsg("could not determine row type for result of %s",
                        funcname),
                 errhint("Provide a non-null record argument, "
                         "or call the function in the FROM clause "
                         "using a column definition list.")));

    Assert(tupdesc);
    cache->argtype = tupdesc->tdtypeid;

    /* If we go through this more than once, avoid memory leak */
    if (cache->c.io.composite.tupdesc)
        FreeTupleDesc(cache->c.io.composite.tupdesc);

    /* Save identified tupdesc */
    old_cxt = MemoryContextSwitchTo(cache->fn_mcxt);
    cache->c.io.composite.tupdesc = CreateTupleDescCopy(tupdesc);
    cache->c.io.composite.base_typid = tupdesc->tdtypeid;
    cache->c.io.composite.base_typmod = tupdesc->tdtypmod;
    MemoryContextSwitchTo(old_cxt);
}

get_scalar()

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

static

Definition at line 1386 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 1061 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_or_ereport(), 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_or_ereport(lex, sem);

    return state->tresult;
}

hash_array_start()

static void hash_array_start ( void *  state )

static

Definition at line 3684 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 3635 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 3611 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 3695 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 5424 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_or_ereport(), 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_or_ereport(lex, sem);
}

iterate_jsonb_values()

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

Definition at line 5356 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, JsonbValue::type, generate_unaccent_rules::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
     * corresponding elements
     */
    while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        if (type == WJB_KEY)
        {
            if (flags & jtiKey)
                action(state, v.val.string.val, v.val.string.len);

            continue;
        }
        else if (!(type == WJB_VALUE || type == WJB_ELEM))
        {
            /* do not call callback for composite JsonbValue */
            continue;
        }

        /* JsonbValue is a value of object or element of array */
        switch (v.type)
        {
            case jbvString:
                if (flags & jtiString)
                    action(state, v.val.string.val, v.val.string.len);
                break;
            case jbvNumeric:
                if (flags & jtiNumeric)
                {
                    char       *val;

                    val = DatumGetCString(DirectFunctionCall1(numeric_out,
                                                              NumericGetDatum(v.val.numeric)));

                    action(state, val, strlen(val));
                    pfree(val);
                }
                break;
            case jbvBool:
                if (flags & jtiBool)
                {
                    if (v.val.boolean)
                        action(state, "true", 4);
                    else
                        action(state, "false", 5);
                }
                break;
            default:
                /* do not call callback for composite JsonbValue */
                break;
        }
    }
}

iterate_values_object_field_start()

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

static

Definition at line 5474 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 5448 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 4774 of file jsonfuncs.c.

References Assert, 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;

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

    /*
     * JsonbIteratorNext reports raw scalars as if they were single-element
     * arrays; hence we only need consider "object" and "array" cases here.
     */
    if (rk1 == WJB_BEGIN_OBJECT && rk2 == WJB_BEGIN_OBJECT)
    {
        /*
         * Both inputs are objects.
         *
         * Append all the tokens from v1 to res, except last WJB_END_OBJECT
         * (because res will not be finished yet).
         */
        pushJsonbValue(state, rk1, NULL);
        while ((r1 = JsonbIteratorNext(it1, &v1, true)) != WJB_END_OBJECT)
            pushJsonbValue(state, r1, &v1);

        /*
         * Append all the tokens from v2 to res, including last WJB_END_OBJECT
         * (the concatenation will be completed).  Any duplicate keys will
         * automatically override the value from the first object.
         */
        while ((r2 = JsonbIteratorNext(it2, &v2, true)) != WJB_DONE)
            res = pushJsonbValue(state, r2, r2 != WJB_END_OBJECT ? &v2 : NULL);
    }
    else if (rk1 == WJB_BEGIN_ARRAY && rk2 == WJB_BEGIN_ARRAY)
    {
        /*
         * Both inputs are arrays.
         */
        pushJsonbValue(state, rk1, 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 */ );
    }
    else if (rk1 == WJB_BEGIN_OBJECT)
    {
        /*
         * We have object || array.
         */
        Assert(rk2 == WJB_BEGIN_ARRAY);

        pushJsonbValue(state, WJB_BEGIN_ARRAY, NULL);

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

        while ((r2 = JsonbIteratorNext(it2, &v2, true)) != WJB_DONE)
            res = pushJsonbValue(state, r2, r2 != WJB_END_ARRAY ? &v2 : NULL);
    }
    else
    {
        /*
         * We have array || object.
         */
        Assert(rk1 == WJB_BEGIN_ARRAY);
        Assert(rk2 == WJB_BEGIN_OBJECT);

        pushJsonbValue(state, WJB_BEGIN_ARRAY, NULL);

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

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

        res = pushJsonbValue(state, WJB_END_ARRAY, NULL);
    }

    return res;
}

JsObjectGetField()

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

static

Definition at line 3267 of file jsonfuncs.c.

References getKeyJsonValueFromContainer(), HASH_FIND, hash_search(), JsValue::is_json, JsObject::is_json, 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 :
            getKeyJsonValueFromContainer(obj->val.jsonb_cont, field, strlen(field),
                                         NULL);

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

json_array_element()

Datum json_array_element

(

PG_FUNCTION_ARGS

)

Definition at line 879 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 922 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 2310 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 2316 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 1790 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_or_ereport(), 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_or_ereport(lex, sem);

    PG_RETURN_INT32(state->count);
}

json_each()

Datum json_each

(

PG_FUNCTION_ARGS

)

Definition at line 1884 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 1896 of file jsonfuncs.c.

References each_worker().

{
    return each_worker(fcinfo, true);
}

json_ereport_error()

void json_ereport_error	(	JsonParseErrorType	error,
		JsonLexContext *	lex
	)

Definition at line 611 of file jsonfuncs.c.

References ereport, errcode(), errdetail(), errmsg(), ERROR, json_errdetail(), JSON_UNICODE_CODE_POINT_ZERO, JSON_UNICODE_HIGH_ESCAPE, and report_json_context().

Referenced by get_array_start(), json_typeof(), and pg_parse_json_or_ereport().

{
    if (error == JSON_UNICODE_HIGH_ESCAPE ||
        error == JSON_UNICODE_CODE_POINT_ZERO)
        ereport(ERROR,
                (errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
                 errmsg("unsupported Unicode escape sequence"),
                 errdetail("%s", json_errdetail(error, lex)),
                 report_json_context(lex)));
    else
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s", "json"),
                 errdetail("%s", json_errdetail(error, lex)),
                 report_json_context(lex)));
}

json_extract_path()

Datum json_extract_path

(

PG_FUNCTION_ARGS

)

Definition at line 966 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 972 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 803 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 841 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 693 of file jsonfuncs.c.

References JsonSemAction::array_start, CStringGetTextDatum, StringInfoData::data, 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_or_ereport(), 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;

    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_or_ereport(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));
    }

    SRF_RETURN_DONE(funcctx);
}

json_populate_record()

Datum json_populate_record

(

PG_FUNCTION_ARGS

)

Definition at line 2508 of file jsonfuncs.c.

References populate_record_worker().

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

json_populate_recordset()

Datum json_populate_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3738 of file jsonfuncs.c.

References populate_recordset_worker().

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

json_strip_nulls()

Datum json_strip_nulls

(

PG_FUNCTION_ARGS

)

Definition at line 4209 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_or_ereport(), 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_or_ereport(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 2515 of file jsonfuncs.c.

References populate_record_worker().

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

json_to_recordset()

Datum json_to_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3745 of file jsonfuncs.c.

References populate_recordset_worker().

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

jsonb_array_element()

Datum jsonb_array_element

(

PG_FUNCTION_ARGS

)

Definition at line 894 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 937 of file jsonfuncs.c.

References element(), getIthJsonbValueFromContainer(), JB_ROOT_COUNT, JB_ROOT_IS_ARRAY, jbvNull, JsonbValueAsText(), PG_GETARG_INT32, PG_GETARG_JSONB_P, PG_RETURN_NULL, PG_RETURN_TEXT_P, Jsonb::root, and JsonbValue::type.

{
    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 && v->type != jbvNull)
        PG_RETURN_TEXT_P(JsonbValueAsText(v));

    PG_RETURN_NULL();
}

jsonb_array_elements()

Datum jsonb_array_elements

(

PG_FUNCTION_ARGS

)

Definition at line 2192 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 2198 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 1818 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 4318 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 4359 of file jsonfuncs.c.

References Assert, ereport, errcode(), errmsg(), ERROR, JB_ROOT_COUNT, JB_ROOT_IS_SCALAR, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), sort-test::key, 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 4412 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, TYPALIGN_INT,
                      &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 4499 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 4680 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().

Referenced by jsonb_set_lax().

{
    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, TYPALIGN_INT,
                      &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 1890 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 1902 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 1427 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 1433 of file jsonfuncs.c.

References get_jsonb_path_all().

{
    return get_jsonb_path_all(fcinfo, true);
}

jsonb_get_element()

Datum jsonb_get_element	(	Jsonb *	jb,
		Datum *	path,
		int	npath,
		bool *	isnull,
		bool	as_text
	)

Definition at line 1471 of file jsonfuncs.c.

References Assert, cstring_to_text(), elog, ERROR, getIthJsonbValueFromContainer(), getKeyJsonValueFromContainer(), i, IsAJsonbScalar, JB_ROOT_IS_ARRAY, JB_ROOT_IS_OBJECT, JB_ROOT_IS_SCALAR, jbvBinary, jbvNull, JsonbToCString(), JsonbValueAsText(), JsonbValueToJsonb(), JsonContainerIsArray, JsonContainerIsObject, JsonContainerIsScalar, JsonContainerSize, PG_RETURN_JSONB_P, PointerGetDatum, Jsonb::root, strtoint(), TextDatumGetCString, JsonbValue::type, JsonbValue::val, VARDATA, VARHDRSZ, and VARSIZE.

Referenced by get_jsonb_path_all(), jsonb_subscript_fetch(), and jsonb_subscript_fetch_old().

{
    JsonbContainer *container = &jb->root;
    JsonbValue *jbvp = NULL;
    int         i;
    bool        have_object = false,
                have_array = false;

    *isnull = false;

    /* Identify whether we have object, array, or scalar at top-level */
    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)
        {
            return PointerGetDatum(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 = getKeyJsonValueFromContainer(container,
                                                VARDATA(path[i]),
                                                VARSIZE(path[i]) - VARHDRSZ,
                                                NULL);
        }
        else if (have_array)
        {
            int         lindex;
            uint32      index;
            char       *indextext = TextDatumGetCString(path[i]);
            char       *endptr;

            errno = 0;
            lindex = strtoint(indextext, &endptr, 10);
            if (endptr == indextext || *endptr != '\0' || errno != 0)
            {
                *isnull = true;
                return PointerGetDatum(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 == INT_MIN || -lindex > nelements)
                {
                    *isnull = true;
                    return PointerGetDatum(NULL);
                }
                else
                    index = nelements + lindex;
            }

            jbvp = getIthJsonbValueFromContainer(container, index);
        }
        else
        {
            /* scalar, extraction yields a null */
            *isnull = true;
            return PointerGetDatum(NULL);
        }

        if (jbvp == NULL)
        {
            *isnull = true;
            return PointerGetDatum(NULL);
        }
        else if (i == npath - 1)
            break;

        if (jbvp->type == jbvBinary)
        {
            container = jbvp->val.binary.data;
            have_object = JsonContainerIsObject(container);
            have_array = JsonContainerIsArray(container);
            Assert(!JsonContainerIsScalar(container));
        }
        else
        {
            Assert(IsAJsonbScalar(jbvp));
            have_object = false;
            have_array = false;
        }
    }

    if (as_text)
    {
        if (jbvp->type == jbvNull)
        {
            *isnull = true;
            return PointerGetDatum(NULL);
        }

        return PointerGetDatum(JsonbValueAsText(jbvp));
    }
    else
    {
        Jsonb      *res = JsonbValueToJsonb(jbvp);

        /* not text mode - just hand back the jsonb */
        PG_RETURN_JSONB_P(res);
    }
}

jsonb_insert()

Datum jsonb_insert

(

PG_FUNCTION_ARGS

)

Definition at line 4724 of file jsonfuncs.c.

References ARR_NDIM, Assert, deconstruct_array(), ereport, errcode(), errmsg(), ERROR, JB_PATH_INSERT_AFTER, JB_PATH_INSERT_BEFORE, JB_ROOT_IS_SCALAR, JsonbIteratorInit(), JsonbToJsonbValue(), JsonbValueToJsonb(), newval, PG_GETARG_ARRAYTYPE_P, PG_GETARG_BOOL, PG_GETARG_JSONB_P, PG_RETURN_JSONB_P, Jsonb::root, and setPath().

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    ArrayType  *path = PG_GETARG