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	json_populate_type (Datum json_val, Oid json_type, Oid typid, int32 typmod, void **cache, MemoryContext mcxt, bool *isnull)
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)
JsonTokenType	json_get_first_token (text *json, bool throw_error)

Macro Definition Documentation

JB_PATH_CONSISTENT_POSITION

#define JB_PATH_CONSISTENT_POSITION   0x0040

Definition at line 49 of file jsonfuncs.c.

JB_PATH_CREATE

#define JB_PATH_CREATE   0x0001

Definition at line 41 of file jsonfuncs.c.

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.

JB_PATH_DELETE

#define JB_PATH_DELETE   0x0002

Definition at line 42 of file jsonfuncs.c.

JB_PATH_FILL_GAPS

#define JB_PATH_FILL_GAPS   0x0020

Definition at line 48 of file jsonfuncs.c.

JB_PATH_INSERT_AFTER

#define JB_PATH_INSERT_AFTER   0x0010

Definition at line 45 of file jsonfuncs.c.

JB_PATH_INSERT_BEFORE

#define JB_PATH_INSERT_BEFORE   0x0008

Definition at line 44 of file jsonfuncs.c.

JB_PATH_REPLACE

#define JB_PATH_REPLACE   0x0004

Definition at line 43 of file jsonfuncs.c.

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.

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.

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.

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.

Typedef Documentation

AlenState

typedef struct AlenState AlenState

ArrayIOData

typedef struct ArrayIOData ArrayIOData

ColumnIOData

typedef struct ColumnIOData ColumnIOData

Definition at line 1 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 1 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.

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

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

Referenced by json_array_length().

alen_object_start()

static void alen_object_start ( void *  state )

static

Definition at line 1840 of file jsonfuncs.c.

{
    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")));
}

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

Referenced by json_array_length().

alen_scalar()

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

static

Definition at line 1852 of file jsonfuncs.c.

{
    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")));
}

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

Referenced by json_array_length().

allocate_record_info()

static RecordIOData * allocate_record_info ( MemoryContext  mcxt, int  ncolumns  )

static

Definition at line 3183 of file jsonfuncs.c.

{
    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;
}

References data, InvalidOid, MemoryContextAlloc(), MemSet, and offsetof.

Referenced by populate_record().

each_array_start()

static void each_array_start ( void *  state )

static

Definition at line 2098 of file jsonfuncs.c.

{
    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")));
}

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

Referenced by each_worker().

each_object_field_end()

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

static

Definition at line 2052 of file jsonfuncs.c.

{
    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);
}

References cstring_to_text_with_len(), CStringGetTextDatum, heap_form_tuple(), len, 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().

each_object_field_start()

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

static

Definition at line 2032 of file jsonfuncs.c.

{
    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;
    }
}

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

each_scalar()

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

static

Definition at line 2110 of file jsonfuncs.c.

{
    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;
}

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

Referenced by each_worker().

each_worker()

static Datum each_worker ( FunctionCallInfo  fcinfo, bool  as_text  )

static

Definition at line 1992 of file jsonfuncs.c.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    JsonLexContext *lex;
    JsonSemAction *sem;
    ReturnSetInfo *rsi;
    EachState  *state;
 
    lex = makeJsonLexContext(json, true);
    state = palloc0(sizeof(EachState));
    sem = palloc0(sizeof(JsonSemAction));
 
    rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 
    SetSingleFuncCall(fcinfo, SRF_SINGLE_BLESS);
    state->tuple_store = rsi->setResult;
    state->ret_tdesc = rsi->setDesc;
 
    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);
 
    PG_RETURN_NULL();
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, JsonSemAction::array_start, CurrentMemoryContext, each_array_start(), each_object_field_end(), each_object_field_start(), each_scalar(), makeJsonLexContext(), MemoryContextDelete(), JsonSemAction::object_field_end, JsonSemAction::object_field_start, palloc0(), PG_GETARG_TEXT_PP, pg_parse_json_or_ereport(), PG_RETURN_NULL, FunctionCallInfoBaseData::resultinfo, JsonSemAction::scalar, JsonSemAction::semstate, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SetSingleFuncCall(), and SRF_SINGLE_BLESS.

Referenced by json_each(), and json_each_text().

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.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    ReturnSetInfo *rsi;
    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;
    SetSingleFuncCall(fcinfo, SRF_SINGLE_BLESS);
 
    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;
            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);
            }
 
            tuplestore_putvalues(rsi->setResult, rsi->setDesc, values, nulls);
 
            /* clean up and switch back */
            MemoryContextSwitchTo(old_cxt);
            MemoryContextReset(tmp_cxt);
        }
    }
 
    MemoryContextDelete(tmp_cxt);
 
    PG_RETURN_NULL();
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), cstring_to_text_with_len(), CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, 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, Jsonb::root, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SetSingleFuncCall(), SRF_SINGLE_BLESS, tuplestore_putvalues(), JsonbValue::type, JsonbValue::val, val, values, WJB_DONE, and WJB_KEY.

Referenced by jsonb_each(), and jsonb_each_text().

elements_array_element_end()

static void elements_array_element_end ( void *  state, bool  isnull  )

static

Definition at line 2295 of file jsonfuncs.c.

{
    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);
}

References cstring_to_text_with_len(), CStringGetTextDatum, heap_form_tuple(), len, 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().

elements_array_element_start()

static void elements_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 2275 of file jsonfuncs.c.

{
    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;
    }
}

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

elements_object_start()

static void elements_object_start ( void *  state )

static

Definition at line 2339 of file jsonfuncs.c.

{
    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)));
}

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

Referenced by elements_worker().

elements_scalar()

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

static

Definition at line 2352 of file jsonfuncs.c.

{
    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;
}

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

Referenced by elements_worker().

elements_worker()

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

static

Definition at line 2235 of file jsonfuncs.c.

{
    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;
    ElementsState *state;
 
    state = palloc0(sizeof(ElementsState));
    sem = palloc0(sizeof(JsonSemAction));
 
    SetSingleFuncCall(fcinfo, SRF_SINGLE_USE_EXPECTED | SRF_SINGLE_BLESS);
    rsi = (ReturnSetInfo *) fcinfo->resultinfo;
    state->tuple_store = rsi->setResult;
    state->ret_tdesc = rsi->setDesc;
 
    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);
 
    PG_RETURN_NULL();
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, JsonSemAction::array_element_end, JsonSemAction::array_element_start, CurrentMemoryContext, elements_array_element_end(), elements_array_element_start(), elements_object_start(), elements_scalar(), makeJsonLexContext(), MemoryContextDelete(), JsonSemAction::object_start, palloc0(), PG_GETARG_TEXT_PP, pg_parse_json_or_ereport(), PG_RETURN_NULL, FunctionCallInfoBaseData::resultinfo, JsonSemAction::scalar, JsonSemAction::semstate, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SetSingleFuncCall(), SRF_SINGLE_BLESS, and SRF_SINGLE_USE_EXPECTED.

Referenced by json_array_elements(), and json_array_elements_text().

elements_worker_jsonb()

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

static

Definition at line 2146 of file jsonfuncs.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    ReturnSetInfo *rsi;
    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;
 
    SetSingleFuncCall(fcinfo,
                      SRF_SINGLE_USE_EXPECTED | SRF_SINGLE_BLESS);
 
    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)
        {
            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);
            }
 
            tuplestore_putvalues(rsi->setResult, rsi->setDesc, values, nulls);
 
            /* clean up and switch back */
            MemoryContextSwitchTo(old_cxt);
            MemoryContextReset(tmp_cxt);
        }
    }
 
    MemoryContextDelete(tmp_cxt);
 
    PG_RETURN_NULL();
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, 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, Jsonb::root, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SetSingleFuncCall(), SRF_SINGLE_BLESS, SRF_SINGLE_USE_EXPECTED, tuplestore_putvalues(), JsonbValue::type, val, values, WJB_DONE, and WJB_ELEM.

Referenced by jsonb_array_elements(), and jsonb_array_elements_text().

get_array_element_end()

static void get_array_element_end ( void *  state, bool  isnull  )

static

Definition at line 1344 of file jsonfuncs.c.

{
    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;
    }
}

References GetState::array_cur_index, cstring_to_text_with_len(), 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().

get_array_element_start()

static void get_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 1298 of file jsonfuncs.c.

{
    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;
        }
    }
}

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

get_array_end()

static void get_array_end ( void *  state )

static

Definition at line 1282 of file jsonfuncs.c.

{
    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);
    }
}

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

Referenced by get_worker().

get_array_start()

static void get_array_start ( void *  state )

static

Definition at line 1244 of file jsonfuncs.c.

{
    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;
    }
}

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

get_json_object_as_hash()

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

static

Definition at line 3508 of file jsonfuncs.c.

{
    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;
}

References JsonSemAction::array_start, CurrentMemoryContext, HASHCTL::entrysize, GetDatabaseEncoding(), 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, len, makeJsonLexContextCstringLen(), NAMEDATALEN, JsonSemAction::object_field_end, JsonSemAction::object_field_start, palloc0(), pg_parse_json_or_ereport(), JsonSemAction::scalar, and JsonSemAction::semstate.

Referenced by JsValueToJsObject().

get_jsonb_path_all()

static Datum get_jsonb_path_all ( FunctionCallInfo  fcinfo, bool  as_text  )

static

Definition at line 1439 of file jsonfuncs.c.

{
    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);
}

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

Referenced by jsonb_extract_path(), and jsonb_extract_path_text().

get_object_end()

static void get_object_end ( void *  state )

static

Definition at line 1134 of file jsonfuncs.c.

{
    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);
    }
}

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

Referenced by get_worker().

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.

{
    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;
    }
}

References cstring_to_text_with_len(), 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().

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.

{
    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;
        }
    }
}

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

get_object_start()

static void get_object_start ( void *  state )

static

Definition at line 1117 of file jsonfuncs.c.

{
    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;
    }
}

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

Referenced by get_worker().

get_path_all()

static Datum get_path_all ( FunctionCallInfo  fcinfo, bool  as_text  )

static

Definition at line 981 of file jsonfuncs.c.

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

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, strtoint(), and TextDatumGetCString.

Referenced by json_extract_path(), and json_extract_path_text().

get_record_type_from_argument()

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

static

Definition at line 3340 of file jsonfuncs.c.

{
    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)));
}

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

get_record_type_from_query()

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

static

Definition at line 3366 of file jsonfuncs.c.

{
    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);
}

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

get_scalar()

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

static

Definition at line 1386 of file jsonfuncs.c.

{
    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;
    }
}

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

Referenced by get_worker().

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.

{
    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;
}

References 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(), makeJsonLexContext(), JsonSemAction::object_end, JsonSemAction::object_field_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc(), palloc0(), pg_parse_json_or_ereport(), JsonSemAction::scalar, and JsonSemAction::semstate.

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

hash_array_start()

static void hash_array_start ( void *  state )

static

Definition at line 3616 of file jsonfuncs.c.

{
    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)));
}

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

Referenced by get_json_object_as_hash().

hash_object_field_end()

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

static

Definition at line 3567 of file jsonfuncs.c.

{
    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;
    }
}

References Assert(), JHashState::hash, HASH_ENTER, hash_search(), JSON_TOKEN_NULL, len, 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().

hash_object_field_start()

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

static

Definition at line 3543 of file jsonfuncs.c.

{
    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;
    }
}

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

hash_scalar()

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

static

Definition at line 3627 of file jsonfuncs.c.

{
    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);
    }
}

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

iterate_json_values()

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

Definition at line 5358 of file jsonfuncs.c.

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

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

Referenced by json_to_tsvector_worker().

iterate_jsonb_values()

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

Definition at line 5290 of file jsonfuncs.c.

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

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

Referenced by jsonb_to_tsvector_worker().

iterate_values_object_field_start()

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

static

Definition at line 5408 of file jsonfuncs.c.

{
    IterateJsonStringValuesState *_state = (IterateJsonStringValuesState *) state;
 
    if (_state->flags & jtiKey)
    {
        char       *val = pstrdup(fname);
 
        _state->action(_state->action_state, val, strlen(val));
    }
}

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

Referenced by iterate_json_values().

iterate_values_scalar()

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

static

Definition at line 5382 of file jsonfuncs.c.

{
    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;
    }
}

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

IteratorConcat()

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

static

Definition at line 4708 of file jsonfuncs.c.

{
    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;
}

References Assert(), JsonbIteratorNext(), pushJsonbValue(), res, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, and WJB_END_OBJECT.

Referenced by jsonb_concat().

JsObjectGetField()

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

static

Definition at line 3199 of file jsonfuncs.c.

{
    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;
    }
}

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

json_array_element()

Datum json_array_element

(

PG_FUNCTION_ARGS

)

Definition at line 879 of file jsonfuncs.c.

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

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

json_array_element_text()

Datum json_array_element_text

(

PG_FUNCTION_ARGS

)

Definition at line 922 of file jsonfuncs.c.

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

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

json_array_elements()

Datum json_array_elements

(

PG_FUNCTION_ARGS

)

Definition at line 2223 of file jsonfuncs.c.

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

References elements_worker().

json_array_elements_text()

Datum json_array_elements_text

(

PG_FUNCTION_ARGS

)

Definition at line 2229 of file jsonfuncs.c.

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

References elements_worker().

json_array_length()

Datum json_array_length

(

PG_FUNCTION_ARGS

)

Definition at line 1790 of file jsonfuncs.c.

{
    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);
}

References alen_array_element_start(), alen_object_start(), alen_scalar(), JsonSemAction::array_element_start, makeJsonLexContext(), JsonSemAction::object_start, palloc0(), PG_GETARG_TEXT_PP, pg_parse_json_or_ereport(), PG_RETURN_INT32, JsonSemAction::scalar, and JsonSemAction::semstate.

json_each()

Datum json_each

(

PG_FUNCTION_ARGS

)

Definition at line 1884 of file jsonfuncs.c.

{
    return each_worker(fcinfo, false);
}

References each_worker().

json_each_text()

Datum json_each_text

(

PG_FUNCTION_ARGS

)

Definition at line 1896 of file jsonfuncs.c.

{
    return each_worker(fcinfo, true);
}

References each_worker().

json_ereport_error()

void json_ereport_error	(	JsonParseErrorType	error,
		JsonLexContext *	lex
	)

Definition at line 611 of file jsonfuncs.c.

{
    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)));
}

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

Referenced by get_array_start(), json_get_first_token(), json_validate(), and pg_parse_json_or_ereport().

json_extract_path()

Datum json_extract_path

(

PG_FUNCTION_ARGS

)

Definition at line 966 of file jsonfuncs.c.

{
    return get_path_all(fcinfo, false);
}

References get_path_all().

json_extract_path_text()

Datum json_extract_path_text

(

PG_FUNCTION_ARGS

)

Definition at line 972 of file jsonfuncs.c.

{
    return get_path_all(fcinfo, true);
}

References get_path_all().

json_get_first_token()

JsonTokenType json_get_first_token	(	text *	json,
		bool	throw_error
	)

Definition at line 5577 of file jsonfuncs.c.

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

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

Referenced by ExecEvalJsonIsPredicate(), and json_typeof().

json_object_field()

Datum json_object_field

(

PG_FUNCTION_ARGS

)

Definition at line 803 of file jsonfuncs.c.

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

References get_worker(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and text_to_cstring().

json_object_field_text()

Datum json_object_field_text

(

PG_FUNCTION_ARGS

)

Definition at line 841 of file jsonfuncs.c.

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

References get_worker(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and text_to_cstring().

json_object_keys()

Datum json_object_keys

(

PG_FUNCTION_ARGS

)

Definition at line 693 of file jsonfuncs.c.

{
    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);
}

References JsonSemAction::array_start, CStringGetTextDatum, StringInfoData::data, if(), 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(), JsonSemAction::scalar, JsonSemAction::semstate, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, JsonLexContext::strval, and FuncCallContext::user_fctx.

json_populate_record()

Datum json_populate_record

(

PG_FUNCTION_ARGS

)

Definition at line 2395 of file jsonfuncs.c.

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

References populate_record_worker().

json_populate_recordset()

Datum json_populate_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3670 of file jsonfuncs.c.

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

References populate_recordset_worker().

json_populate_type()

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

Definition at line 3139 of file jsonfuncs.c.

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

References DatumGetJsonbP, DatumGetTextPP, JsValue::is_json, jbvBinary, JsValue::json, JSON_TOKEN_INVALID, JsValue::jsonb, MemoryContextAllocZero(), PointerGetDatum, populate_record_field(), Jsonb::root, JsonbValue::type, JsValue::val, JsonbValue::val, VARDATA_ANY, VARHDRSZ, VARSIZE, and VARSIZE_ANY_EXHDR.

Referenced by ExecEvalJsonExprCoercion().

json_strip_nulls()

Datum json_strip_nulls

(

PG_FUNCTION_ARGS

)

Definition at line 4144 of file jsonfuncs.c.

{
    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));
}

References JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, cstring_to_text_with_len(), makeJsonLexContext(), makeStringInfo(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc0(), PG_GETARG_TEXT_PP, pg_parse_json_or_ereport(), PG_RETURN_TEXT_P, JsonSemAction::scalar, JsonSemAction::semstate, sn_array_element_start(), sn_array_end(), sn_array_start(), sn_object_end(), sn_object_field_start(), sn_object_start(), and sn_scalar().

json_to_record()

Datum json_to_record

(

PG_FUNCTION_ARGS

)

Definition at line 2402 of file jsonfuncs.c.

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

References populate_record_worker().

json_to_recordset()

Datum json_to_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3677 of file jsonfuncs.c.

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

References populate_recordset_worker().

jsonb_array_element()

Datum jsonb_array_element

(

PG_FUNCTION_ARGS

)

Definition at line 894 of file jsonfuncs.c.

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

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

Datum jsonb_array_element_text

(

PG_FUNCTION_ARGS

)

Definition at line 937 of file jsonfuncs.c.

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

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

Datum jsonb_array_elements

(

PG_FUNCTION_ARGS

)

Definition at line 2134 of file jsonfuncs.c.

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

References elements_worker_jsonb().

jsonb_array_elements_text()

Datum jsonb_array_elements_text

(

PG_FUNCTION_ARGS

)

Definition at line 2140 of file jsonfuncs.c.

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

References elements_worker_jsonb().

jsonb_array_length()

Datum jsonb_array_length

(

PG_FUNCTION_ARGS

)

Definition at line 1818 of file jsonfuncs.c.

{
    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));
}

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

Datum jsonb_concat

(

PG_FUNCTION_ARGS

)

Definition at line 4252 of file jsonfuncs.c.

{
    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));
}

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

jsonb_delete()

Datum jsonb_delete

(

PG_FUNCTION_ARGS

)

Definition at line 4293 of file jsonfuncs.c.

{
    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));
}

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(), res, Jsonb::root, JsonbValue::type, JsonbValue::val, VARDATA_ANY, VARSIZE_ANY_EXHDR, WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, and WJB_KEY.

jsonb_delete_array()

Datum jsonb_delete_array

(

PG_FUNCTION_ARGS

)

Definition at line 4346 of file jsonfuncs.c.

{
    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));
}

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(), res, Jsonb::root, JsonbValue::type, JsonbValue::val, VARDATA_ANY, VARSIZE_ANY_EXHDR, WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, and WJB_KEY.

jsonb_delete_idx()

Datum jsonb_delete_idx

(

PG_FUNCTION_ARGS

)

Definition at line 4433 of file jsonfuncs.c.

{
    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));
}

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(), res, Jsonb::root, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_DONE, and WJB_ELEM.

jsonb_delete_path()

Datum jsonb_delete_path

(

PG_FUNCTION_ARGS

)

Definition at line 4614 of file jsonfuncs.c.

{
    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));
}

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, res, Jsonb::root, and setPath().

Referenced by jsonb_set_lax().

jsonb_each()

Datum jsonb_each

(

PG_FUNCTION_ARGS

)

Definition at line 1890 of file jsonfuncs.c.

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

References each_worker_jsonb().

jsonb_each_text()

Datum jsonb_each_text

(

PG_FUNCTION_ARGS

)

Definition at line 1902 of file jsonfuncs.c.

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

References each_worker_jsonb().

jsonb_extract_path()

Datum jsonb_extract_path

(

PG_FUNCTION_ARGS

)

Definition at line 1427 of file jsonfuncs.c.

{
    return get_jsonb_path_all(fcinfo, false);
}

References get_jsonb_path_all().

jsonb_extract_path_text()

Datum jsonb_extract_path_text

(

PG_FUNCTION_ARGS

)

Definition at line 1433 of file jsonfuncs.c.

{
    return get_jsonb_path_all(fcinfo, true);
}

References get_jsonb_path_all().

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.

{
    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);
    }
}

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

jsonb_insert()

Datum jsonb_insert

(

PG_FUNCTION_ARGS

)

Definition at line 4658 of file jsonfuncs.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    ArrayType  *path = PG_GETARG_ARRAYTYPE_P(1);
    Jsonb      *newjsonb = PG_GETARG_JSONB_P(2);
    JsonbValue  newval;
    bool        after = PG_GETARG_BOOL(3);
    JsonbValue *res = NULL;
    Datum      *path_elems;
    bool       *path_nulls;
    int         path_len;
    JsonbIterator *it;
    JsonbParseState *st = NULL;
 
    JsonbToJsonbValue(newjsonb, &newval);
 
    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 set path in scalar")));
 
    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, &newval,
                  after ? JB_PATH_INSERT_AFTER : JB_PATH_INSERT_BEFORE);
 
    Assert(res != NULL);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}

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, res, Jsonb::root, and setPath().

jsonb_object_field()

Datum jsonb_object_field

(

PG_FUNCTION_ARGS

)

Definition at line 819 of file jsonfuncs.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    text       *key = PG_GETARG_TEXT_PP(1);
    JsonbValue *v;
    JsonbValue  vbuf;
 
    if (!JB_ROOT_IS_OBJECT(jb))
        PG_RETURN_NULL();
 
    v = getKeyJsonValueFromContainer(&jb->root,
                                     VARDATA_ANY(key),
                                     VARSIZE_ANY_EXHDR(key),
                                     &vbuf);
 
    if (v != NULL)
        PG_RETURN_JSONB_P(JsonbValueToJsonb(v));
 
    PG_RETURN_NULL();
}

References getKeyJsonValueFromContainer(), JB_ROOT_IS_OBJECT, JsonbValueToJsonb(), sort-test::key, PG_GETARG_JSONB_P, PG_GETARG_TEXT_PP, PG_RETURN_JSONB_P, PG_RETURN_NULL, Jsonb::root, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

jsonb_object_field_text()

Datum jsonb_object_field_text

(

PG_FUNCTION_ARGS

)

Definition at line 857 of file jsonfuncs.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    text       *key = PG_GETARG_TEXT_PP(1);
    JsonbValue *v;
    JsonbValue  vbuf;
 
    if (!JB_ROOT_IS_OBJECT(jb))
        PG_RETURN_NULL();
 
    v = getKeyJsonValueFromContainer(&jb->root,
                                     VARDATA_ANY(key),
                                     VARSIZE_ANY_EXHDR(key),
                                     &vbuf);
 
    if (v != NULL && v->type != jbvNull)
        PG_RETURN_TEXT_P(JsonbValueAsText(v));
 
    PG_RETURN_NULL();
}

References getKeyJsonValueFromContainer(), JB_ROOT_IS_OBJECT, jbvNull, JsonbValueAsText(), sort-test::key, PG_GETARG_JSONB_P, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, Jsonb::root, JsonbValue::type, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

jsonb_object_keys()

Datum jsonb_object_keys

(

PG_FUNCTION_ARGS

)

Definition at line 538 of file jsonfuncs.c.

{
    FuncCallContext *funcctx;
    OkeysState *state;
 
    if (SRF_IS_FIRSTCALL())
    {
        MemoryContext oldcontext;
        Jsonb      *jb = PG_GETARG_JSONB_P(0);
        bool        skipNested = false;
        JsonbIterator *it;
        JsonbValue  v;
        JsonbIteratorToken r;
 
        if (JB_ROOT_IS_SCALAR(jb))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("cannot call %s on a scalar",
                            "jsonb_object_keys")));
        else if (JB_ROOT_IS_ARRAY(jb))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("cannot call %s on an array",
                            "jsonb_object_keys")));
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        state = palloc(sizeof(OkeysState));
 
        state->result_size = JB_ROOT_COUNT(jb);
        state->result_count = 0;
        state->sent_count = 0;
        state->result = palloc(state->result_size * sizeof(char *));
 
        it = JsonbIteratorInit(&jb->root);
 
        while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
        {
            skipNested = true;
 
            if (r == WJB_KEY)
            {
                char       *cstr;
 
                cstr = palloc(v.val.string.len + 1 * sizeof(char));
                memcpy(cstr, v.val.string.val, v.val.string.len);
                cstr[v.val.string.len] = '\0';
                state->result[state->result_count++] = cstr;
            }
        }
 
        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);
}

References CStringGetTextDatum, ereport, errcode(), errmsg(), ERROR, if(), JB_ROOT_COUNT, JB_ROOT_IS_ARRAY, JB_ROOT_IS_SCALAR, JsonbIteratorInit(), JsonbIteratorNext(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, palloc(), PG_GETARG_JSONB_P, Jsonb::root, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, FuncCallContext::user_fctx, JsonbValue::val, WJB_DONE, and WJB_KEY.

jsonb_populate_record()

Datum jsonb_populate_record

(

PG_FUNCTION_ARGS

)

Definition at line 2381 of file jsonfuncs.c.

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

References populate_record_worker().

jsonb_populate_recordset()

Datum jsonb_populate_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3656 of file jsonfuncs.c.

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

References populate_recordset_worker().

jsonb_pretty()

Datum jsonb_pretty

(

PG_FUNCTION_ARGS

)

Definition at line 4236 of file jsonfuncs.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    StringInfo  str = makeStringInfo();
 
    JsonbToCStringIndent(str, &jb->root, VARSIZE(jb));
 
    PG_RETURN_TEXT_P(cstring_to_text_with_len(str->data, str->len));
}

References cstring_to_text_with_len(), JsonbToCStringIndent(), makeStringInfo(), PG_GETARG_JSONB_P, PG_RETURN_TEXT_P, Jsonb::root, generate_unaccent_rules::str, and VARSIZE.

jsonb_set()

Datum jsonb_set

(

PG_FUNCTION_ARGS

)

Definition at line 4497 of file jsonfuncs.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    ArrayType  *path = PG_GETARG_ARRAYTYPE_P(1);
    Jsonb      *newjsonb = PG_GETARG_JSONB_P(2);
    JsonbValue  newval;
    bool        create = PG_GETARG_BOOL(3);
    JsonbValue *res = NULL;
    Datum      *path_elems;
    bool       *path_nulls;
    int         path_len;
    JsonbIterator *it;
    JsonbParseState *st = NULL;
 
    JsonbToJsonbValue(newjsonb, &newval);
 
    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 set path in scalar")));
 
    if (JB_ROOT_COUNT(in) == 0 && !create)
        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, &newval, create ? JB_PATH_CREATE : JB_PATH_REPLACE);
 
    Assert(res != NULL);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}

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

Referenced by jsonb_set_lax().

jsonb_set_element()

Datum jsonb_set_element	(	Jsonb *	jb,
		Datum *	path,
		int	path_len,
		JsonbValue *	newval
	)

Definition at line 1617 of file jsonfuncs.c.

{
    JsonbValue *res;
    JsonbParseState *state = NULL;
    JsonbIterator *it;
    bool       *path_nulls = palloc0(path_len * sizeof(bool));
 
    if (newval->type == jbvArray && newval->val.array.rawScalar)
        *newval = newval->val.array.elems[0];
 
    it = JsonbIteratorInit(&jb->root);
 
    res = setPath(&it, path, path_nulls, path_len, &state, 0, newval,
                  JB_PATH_CREATE | JB_PATH_FILL_GAPS |
                  JB_PATH_CONSISTENT_POSITION);
 
    pfree(path_nulls);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}

References JB_PATH_CONSISTENT_POSITION, JB_PATH_CREATE, JB_PATH_FILL_GAPS, jbvArray, JsonbIteratorInit(), JsonbValueToJsonb(), newval, palloc0(), pfree(), PG_RETURN_JSONB_P, res, Jsonb::root, and setPath().

Referenced by jsonb_subscript_assign().

jsonb_set_lax()

Datum jsonb_set_lax

(

PG_FUNCTION_ARGS

)

Definition at line 4547 of file jsonfuncs.c.

{
    /* Jsonb       *in = PG_GETARG_JSONB_P(0); */
    /* ArrayType  *path = PG_GETARG_ARRAYTYPE_P(1); */
    /* Jsonb      *newval = PG_GETARG_JSONB_P(2); */
    /* bool     create = PG_GETARG_BOOL(3); */
    text       *handle_null;
    char       *handle_val;
 
    if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(3))
        PG_RETURN_NULL();
 
    /* could happen if they pass in an explicit NULL */
    if (PG_ARGISNULL(4))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("null_value_treatment must be \"delete_key\", \"return_target\", \"use_json_null\", or \"raise_exception\"")));
 
    /* if the new value isn't an SQL NULL just call jsonb_set */
    if (!PG_ARGISNULL(2))
        return jsonb_set(fcinfo);
 
    handle_null = PG_GETARG_TEXT_P(4);
    handle_val = text_to_cstring(handle_null);
 
    if (strcmp(handle_val, "raise_exception") == 0)
    {
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("JSON value must not be null"),
                 errdetail("Exception was raised because null_value_treatment is \"raise_exception\"."),
                 errhint("To avoid, either change the null_value_treatment argument or ensure that an SQL NULL is not passed.")));
        return (Datum) 0;       /* silence stupider compilers */
    }
    else if (strcmp(handle_val, "use_json_null") == 0)
    {
        Datum       newval;
 
        newval = DirectFunctionCall1(jsonb_in, CStringGetDatum("null"));
 
        fcinfo->args[2].value = newval;
        fcinfo->args[2].isnull = false;
        return jsonb_set(fcinfo);
    }
    else if (strcmp(handle_val, "delete_key") == 0)
    {
        return jsonb_delete_path(fcinfo);
    }
    else if (strcmp(handle_val, "return_target") == 0)
    {
        Jsonb      *in = PG_GETARG_JSONB_P(0);
 
        PG_RETURN_JSONB_P(in);
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("null_value_treatment must be \"delete_key\", \"return_target\", \"use_json_null\", or \"raise_exception\"")));
        return (Datum) 0;       /* silence stupider compilers */
    }
}

References CStringGetDatum, DirectFunctionCall1, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, jsonb_delete_path(), jsonb_in(), jsonb_set(), newval, PG_ARGISNULL, PG_GETARG_JSONB_P, PG_GETARG_TEXT_P, PG_RETURN_JSONB_P, PG_RETURN_NULL, and text_to_cstring().

jsonb_strip_nulls()

Datum jsonb_strip_nulls

(

PG_FUNCTION_ARGS

)

Definition at line 4178 of file jsonfuncs.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    JsonbIterator *it;
    JsonbParseState *parseState = NULL;
    JsonbValue *res = NULL;
    JsonbValue  v,
                k;
    JsonbIteratorToken type;
    bool        last_was_key = false;
 
    if (JB_ROOT_IS_SCALAR(jb))
        PG_RETURN_POINTER(jb);
 
    it = JsonbIteratorInit(&jb->root);
 
    while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        Assert(!(type == WJB_KEY && last_was_key));
 
        if (type == WJB_KEY)
        {
            /* stash the key until we know if it has a null value */
            k = v;
            last_was_key = true;
            continue;
        }
 
        if (last_was_key)
        {
            /* if the last element was a key this one can't be */
            last_was_key = false;
 
            /* skip this field if value is null */
            if (type == WJB_VALUE && v.type == jbvNull)
                continue;
 
            /* otherwise, do a delayed push of the key */
            (void) pushJsonbValue(&parseState, WJB_KEY, &k);
        }
 
        if (type == WJB_VALUE || type == WJB_ELEM)
            res = pushJsonbValue(&parseState, type, &v);
        else
            res = pushJsonbValue(&parseState, type, NULL);
    }
 
    Assert(res != NULL);
 
    PG_RETURN_POINTER(JsonbValueToJsonb(res));
}

References Assert(), JB_ROOT_IS_SCALAR, jbvNull, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), PG_GETARG_JSONB_P, PG_RETURN_POINTER, pushJsonbValue(), res, Jsonb::root, generate_unaccent_rules::type, JsonbValue::type, WJB_DONE, WJB_ELEM, WJB_KEY, and WJB_VALUE.

jsonb_to_record()

Datum jsonb_to_record

(

PG_FUNCTION_ARGS

)

Definition at line 2388 of file jsonfuncs.c.

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

References populate_record_worker().

jsonb_to_recordset()

Datum jsonb_to_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3663 of file jsonfuncs.c.

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

References populate_recordset_worker().

JsonbValueAsText()

static text * JsonbValueAsText ( JsonbValue *  v )

static

Definition at line 1743 of file jsonfuncs.c.

{
    switch (v->type)
    {
        case jbvNull:
            return NULL;
 
        case jbvBool:
            return v->val.boolean ?
                cstring_to_text_with_len("true", 4) :
                cstring_to_text_with_len("false", 5);
 
        case jbvString:
            return cstring_to_text_with_len(v->val.string.val,
                                            v->val.string.len);
 
        case jbvNumeric:
            {
                Datum       cstr;
 
                cstr = DirectFunctionCall1(numeric_out,
                                           PointerGetDatum(v->val.numeric));
 
                return cstring_to_text(DatumGetCString(cstr));
            }
 
        case jbvBinary:
            {
                StringInfoData jtext;
 
                initStringInfo(&jtext);
                (void) JsonbToCString(&jtext, v->val.binary.data,
                                      v->val.binary.len);
 
                return cstring_to_text_with_len(jtext.data, jtext.len);
            }
 
        default:
            elog(ERROR, "unrecognized jsonb type: %d", (int) v->type);
            return NULL;
    }
}

References cstring_to_text(), cstring_to_text_with_len(), StringInfoData::data, DatumGetCString, DirectFunctionCall1, elog, ERROR, initStringInfo(), jbvBinary, jbvBool, jbvNull, jbvNumeric, jbvString, JsonbToCString(), StringInfoData::len, numeric_out(), PointerGetDatum, JsonbValue::type, and JsonbValue::val.

Referenced by each_worker_jsonb(), elements_worker_jsonb(), jsonb_array_element_text(), jsonb_get_element(), and jsonb_object_field_text().

JsValueToJsObject()

static void JsValueToJsObject ( JsValue *  jsv, JsObject *  jso  )

static

Definition at line 2767 of file jsonfuncs.c.

{
    jso->is_json = jsv->is_json;
 
    if (jsv->is_json)
    {
        /* convert plain-text json into a hash table */
        jso->val.json_hash =
            get_json_object_as_hash(jsv->val.json.str,
                                    jsv->val.json.len >= 0
                                    ? jsv->val.json.len
                                    : strlen(jsv->val.json.str),
                                    "populate_composite");
    }
    else
    {
        JsonbValue *jbv = jsv->val.jsonb;
 
        if (jbv->type == jbvBinary &&
            JsonContainerIsObject(jbv->val.binary.data))
        {
            jso->val.jsonb_cont = jbv->val.binary.data;
        }
        else
        {
            bool        is_scalar;
 
            is_scalar = IsAJsonbScalar(jbv) ||
                (jbv->type == jbvBinary &&
                 JsonContainerIsScalar(jbv->val.binary.data));
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     is_scalar
                     ? errmsg("cannot call %s on a scalar",
                              "populate_composite")
                     : errmsg("cannot call %s on an array",
                              "populate_composite")));
        }
    }
}

References ereport, errcode(), errmsg(), ERROR, get_json_object_as_hash(), JsValue::is_json, JsObject::is_json, IsAJsonbScalar, jbvBinary, JsValue::json, JsObject::json_hash, JsValue::jsonb, JsObject::jsonb_cont, JsonContainerIsObject, JsonContainerIsScalar, JsonbValue::type, JsValue::val, JsObject::val, and JsonbValue::val.

Referenced by populate_composite().

makeJsonLexContext()

JsonLexContext* makeJsonLexContext	(	text *	json,
		bool	need_escapes
	)

Definition at line 517 of file jsonfuncs.c.

{
    return makeJsonLexContextCstringLen(VARDATA_ANY(json),
                                        VARSIZE_ANY_EXHDR(json),
                                        GetDatabaseEncoding(),
                                        need_escapes);
}

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

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

okeys_array_start()

static void okeys_array_start ( void *  state )

static

Definition at line 770 of file jsonfuncs.c.

{
    OkeysState *_state = (OkeysState *) state;
 
    /* top level must be a json object */
    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot call %s on an array",
                        "json_object_keys")));
}

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

Referenced by json_object_keys().

okeys_object_field_start()

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

static

Definition at line 749 of file jsonfuncs.c.

{
    OkeysState *_state = (OkeysState *) state;
 
    /* only collecting keys for the top level object */
    if (_state->lex->lex_level != 1)
        return;
 
    /* enlarge result array if necessary */
    if (_state->result_count >= _state->result_size)
    {
        _state->result_size *= 2;
        _state->result = (char **)
            repalloc(_state->result, sizeof(char *) * _state->result_size);
    }
 
    /* save a copy of the field name */
    _state->result[_state->result_count++] = pstrdup(fname);
}

References OkeysState::lex, JsonLexContext::lex_level, pstrdup(), repalloc(), OkeysState::result, OkeysState::result_count, and OkeysState::result_size.

Referenced by json_object_keys().

okeys_scalar()

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

static

Definition at line 783 of file jsonfuncs.c.

{
    OkeysState *_state = (OkeysState *) state;
 
    /* top level must be a json object */
    if (_state->lex->lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot call %s on a scalar",
                        "json_object_keys")));
}

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

Referenced by json_object_keys().

parse_jsonb_index_flags()

uint32 parse_jsonb_index_flags

(

Jsonb *

jb

)

Definition at line 5222 of file jsonfuncs.c.

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

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

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

pg_parse_json_or_ereport()

void pg_parse_json_or_ereport	(	JsonLexContext *	lex,
		JsonSemAction *	sem
	)

Definition at line 501 of file jsonfuncs.c.

{
    JsonParseErrorType result;
 
    result = pg_parse_json(lex, sem);
    if (result != JSON_SUCCESS)
        json_ereport_error(result, lex);
}

References json_ereport_error(), JSON_SUCCESS, and pg_parse_json().

Referenced by datum_to_jsonb(), each_worker(), elements_worker(), get_json_object_as_hash(), get_worker(), iterate_json_values(), json_array_length(), json_in(), json_object_keys(), json_recv(), json_strip_nulls(), jsonb_from_cstring(), populate_array_json(), populate_recordset_worker(), and transform_json_string_values().

populate_array()

static Datum populate_array ( ArrayIOData *  aio, const char *  colname, MemoryContext  mcxt, JsValue *  jsv  )

static

Definition at line 2720 of file jsonfuncs.c.

{
    PopulateArrayContext ctx;
    Datum       result;
    int        *lbs;
    int         i;
 
    ctx.aio = aio;
    ctx.mcxt = mcxt;
    ctx.acxt = CurrentMemoryContext;
    ctx.astate = initArrayResult(aio->element_type, ctx.acxt, true);
    ctx.colname = colname;
    ctx.ndims = 0;              /* unknown yet */
    ctx.dims = NULL;
    ctx.sizes = NULL;
 
    if (jsv->is_json)
        populate_array_json(&ctx, jsv->val.json.str,
                            jsv->val.json.len >= 0 ? jsv->val.json.len
                            : strlen(jsv->val.json.str));
    else
    {
        populate_array_dim_jsonb(&ctx, jsv->val.jsonb, 1);
        ctx.dims[0] = ctx.sizes[0];
    }
 
    Assert(ctx.ndims > 0);
 
    lbs = palloc(sizeof(int) * ctx.ndims);
 
    for (i = 0; i < ctx.ndims; i++)
        lbs[i] = 1;
 
    result = makeMdArrayResult(ctx.astate, ctx.ndims, ctx.dims, lbs,
                               ctx.acxt, true);
 
    pfree(ctx.dims);
    pfree(ctx.sizes);
    pfree(lbs);
 
    return result;
}

References PopulateArrayContext::acxt, PopulateArrayContext::aio, Assert(), PopulateArrayContext::astate, PopulateArrayContext::colname, CurrentMemoryContext, PopulateArrayContext::dims, ArrayIOData::element_type, i, initArrayResult(), JsValue::is_json, JsValue::json, JsValue::jsonb, makeMdArrayResult(), PopulateArrayContext::mcxt, PopulateArrayContext::ndims, palloc(), pfree(), populate_array_dim_jsonb(), populate_array_json(), PopulateArrayContext::sizes, and JsValue::val.

Referenced by populate_record_field().

populate_array_array_end()

static void populate_array_array_end ( void *  _state )

static

Definition at line 2528 of file jsonfuncs.c.

{
    PopulateArrayState *state = (PopulateArrayState *) _state;
    PopulateArrayContext *ctx = state->ctx;
    int         ndim = state->lex->lex_level;
 
    if (ctx->ndims <= 0)
        populate_array_assign_ndims(ctx, ndim + 1);
 
    if (ndim < ctx->ndims)
        populate_array_check_dimension(ctx, ndim);
}

References PopulateArrayContext::ndims, populate_array_assign_ndims(), and populate_array_check_dimension().

Referenced by populate_array_json().

populate_array_assign_ndims()

static void populate_array_assign_ndims ( PopulateArrayContext *  ctx, int  ndims  )

static

Definition at line 2453 of file jsonfuncs.c.

{
    int         i;
 
    Assert(ctx->ndims <= 0);
 
    if (ndims <= 0)
        populate_array_report_expected_array(ctx, ndims);
 
    ctx->ndims = ndims;
    ctx->dims = palloc(sizeof(int) * ndims);
    ctx->sizes = palloc0(sizeof(int) * ndims);
 
    for (i = 0; i < ndims; i++)
        ctx->dims[i] = -1;      /* dimensions are unknown yet */
}

References Assert(), PopulateArrayContext::dims, i, PopulateArrayContext::ndims, palloc(), palloc0(), populate_array_report_expected_array(), and PopulateArrayContext::sizes.

Referenced by populate_array_array_end(), populate_array_dim_jsonb(), populate_array_object_start(), and populate_array_scalar().

populate_array_check_dimension()

static void populate_array_check_dimension ( PopulateArrayContext *  ctx, int  ndim  )

static

Definition at line 2472 of file jsonfuncs.c.

{
    int         dim = ctx->sizes[ndim]; /* current dimension counter */
 
    if (ctx->dims[ndim] == -1)
        ctx->dims[ndim] = dim;  /* assign dimension if not yet known */
    else if (ctx->dims[ndim] != dim)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed JSON array"),
                 errdetail("Multidimensional arrays must have "
                           "sub-arrays with matching dimensions.")));
 
    /* reset the current array dimension size counter */
    ctx->sizes[ndim] = 0;
 
    /* increment the parent dimension counter if it is a nested sub-array */
    if (ndim > 0)
        ctx->sizes[ndim - 1]++;
}

References PopulateArrayContext::dims, ereport, errcode(), errdetail(), errmsg(), ERROR, and PopulateArrayContext::sizes.

Referenced by populate_array_array_end(), and populate_array_dim_jsonb().

populate_array_dim_jsonb()

static void populate_array_dim_jsonb ( PopulateArrayContext *  ctx, JsonbValue *  jbv, int  ndim  )

static

Definition at line 2649 of file jsonfuncs.c.

{
    JsonbContainer *jbc = jbv->val.binary.data;
    JsonbIterator *it;
    JsonbIteratorToken tok;
    JsonbValue  val;
    JsValue     jsv;
 
    check_stack_depth();
 
    if (jbv->type != jbvBinary ||
        !JsonContainerIsArray(jbc) ||
        JsonContainerIsScalar(jbc))
        populate_array_report_expected_array(ctx, ndim - 1);
 
    it = JsonbIteratorInit(jbc);
 
    tok = JsonbIteratorNext(&it, &val, true);
    Assert(tok == WJB_BEGIN_ARRAY);
 
    tok = JsonbIteratorNext(&it, &val, true);
 
    /*
     * If the number of dimensions is not yet known and we have found end of
     * the array, or the first child element is not an array, then assign the
     * number of dimensions now.
     */
    if (ctx->ndims <= 0 &&
        (tok == WJB_END_ARRAY ||
         (tok == WJB_ELEM &&
          (val.type != jbvBinary ||
           !JsonContainerIsArray(val.val.binary.data)))))
        populate_array_assign_ndims(ctx, ndim);
 
    jsv.is_json = false;
    jsv.val.jsonb = &val;
 
    /* process all the array elements */
    while (tok == WJB_ELEM)
    {
        /*
         * Recurse only if the dimensions of dimensions is still unknown or if
         * it is not the innermost dimension.
         */
        if (ctx->ndims > 0 && ndim >= ctx->ndims)
            populate_array_element(ctx, ndim, &jsv);
        else
        {
            /* populate child sub-array */
            populate_array_dim_jsonb(ctx, &val, ndim + 1);
 
            /* number of dimensions should be already known */
            Assert(ctx->ndims > 0 && ctx->dims);
 
            populate_array_check_dimension(ctx, ndim);
        }
 
        tok = JsonbIteratorNext(&it, &val, true);
    }
 
    Assert(tok == WJB_END_ARRAY);
 
    /* free iterator, iterating until WJB_DONE */
    tok = JsonbIteratorNext(&it, &val, true);
    Assert(tok == WJB_DONE && !it);
}

References Assert(), check_stack_depth(), PopulateArrayContext::dims, JsValue::is_json, jbvBinary, JsValue::jsonb, JsonbIteratorInit(), JsonbIteratorNext(), JsonContainerIsArray, JsonContainerIsScalar, PopulateArrayContext::ndims, populate_array_assign_ndims(), populate_array_check_dimension(), populate_array_element(), populate_array_report_expected_array(), JsonbValue::type, JsValue::val, JsonbValue::val, val, WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, and WJB_END_ARRAY.

Referenced by populate_array().

populate_array_element()

static void populate_array_element ( PopulateArrayContext *  ctx, int  ndim, JsValue *  jsv  )

static

Definition at line 2494 of file jsonfuncs.c.

{
    Datum       element;
    bool        element_isnull;
 
    /* populate the array element */
    element = populate_record_field(ctx->aio->element_info,
                                    ctx->aio->element_type,
                                    ctx->aio->element_typmod,
                                    NULL, ctx->mcxt, PointerGetDatum(NULL),
                                    jsv, &element_isnull);
 
    accumArrayResult(ctx->astate, element, element_isnull,
                     ctx->aio->element_type, ctx->acxt);
 
    Assert(ndim > 0);
    ctx->sizes[ndim - 1]++;     /* increment current dimension counter */
}

References accumArrayResult(), PopulateArrayContext::acxt, PopulateArrayContext::aio, Assert(), PopulateArrayContext::astate, element(), ArrayIOData::element_info, ArrayIOData::element_type, ArrayIOData::element_typmod, PopulateArrayContext::mcxt, PointerGetDatum, populate_record_field(), and PopulateArrayContext::sizes.

Referenced by populate_array_dim_jsonb(), and populate_array_element_end().

populate_array_element_end()

static void populate_array_element_end ( void *  _state, bool  isnull  )

static

Definition at line 2559 of file jsonfuncs.c.

{
    PopulateArrayState *state = (PopulateArrayState *) _state;
    PopulateArrayContext *ctx = state->ctx;
    int         ndim = state->lex->lex_level;
 
    Assert(ctx->ndims > 0);
 
    if (ndim == ctx->ndims)
    {
        JsValue     jsv;
 
        jsv.is_json = true;
        jsv.val.json.type = state->element_type;
 
        if (isnull)
        {
            Assert(jsv.val.json.type == JSON_TOKEN_NULL);
            jsv.val.json.str = NULL;
            jsv.val.json.len = 0;
        }
        else if (state->element_scalar)
        {
            jsv.val.json.str = state->element_scalar;
            jsv.val.json.len = -1;  /* null-terminated */
        }
        else
        {
            jsv.val.json.str = state->element_start;
            jsv.val.json.len = (state->lex->prev_token_terminator -
                                state->element_start) * sizeof(char);
        }
 
        populate_array_element(ctx, ndim, &jsv);
    }
}

References Assert(), JsValue::is_json, JsValue::json, JSON_TOKEN_NULL, PopulateArrayContext::ndims, populate_array_element(), and JsValue::val.

Referenced by populate_array_json().

populate_array_element_start()

static void populate_array_element_start ( void *  _state, bool  isnull  )

static

Definition at line 2543 of file jsonfuncs.c.

{
    PopulateArrayState *state = (PopulateArrayState *) _state;
    int         ndim = state->lex->lex_level;
 
    if (state->ctx->ndims <= 0 || ndim == state->ctx->ndims)
    {
        /* remember current array element start */
        state->element_start = state->lex->token_start;
        state->element_type = state->lex->token_type;
        state->element_scalar = NULL;
    }
}

Referenced by populate_array_json().

populate_array_json()

static void populate_array_json ( PopulateArrayContext *  ctx, char *  json, int  len  )

static

Definition at line 2620 of file jsonfuncs.c.

{
    PopulateArrayState state;
    JsonSemAction sem;
 
    state.lex = makeJsonLexContextCstringLen(json, len, GetDatabaseEncoding(), true);
    state.ctx = ctx;
 
    memset(&sem, 0, sizeof(sem));
    sem.semstate = (void *) &state;
    sem.object_start = populate_array_object_start;
    sem.array_end = populate_array_array_end;
    sem.array_element_start = populate_array_element_start;
    sem.array_element_end = populate_array_element_end;
    sem.scalar = populate_array_scalar;
 
    pg_parse_json_or_ereport(state.lex, &sem);
 
    /* number of dimensions should be already known */
    Assert(ctx->ndims > 0 && ctx->dims);
 
    pfree(state.lex);
}

References JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, Assert(), PopulateArrayContext::dims, GetDatabaseEncoding(), len, makeJsonLexContextCstringLen(), PopulateArrayContext::ndims, JsonSemAction::object_start, pfree(), pg_parse_json_or_ereport(), populate_array_array_end(), populate_array_element_end(), populate_array_element_start(), populate_array_object_start(), populate_array_scalar(), JsonSemAction::scalar, and JsonSemAction::semstate.

Referenced by populate_array().

populate_array_object_start()

static void populate_array_object_start ( void *  _state )

static

Definition at line 2515 of file jsonfuncs.c.

{
    PopulateArrayState *state = (PopulateArrayState *) _state;
    int         ndim = state->lex->lex_level;
 
    if (state->ctx->ndims <= 0)
        populate_array_assign_ndims(state->ctx, ndim);
    else if (ndim < state->ctx->ndims)
        populate_array_report_expected_array(state->ctx, ndim);
}

References populate_array_assign_ndims(), and populate_array_report_expected_array().

Referenced by populate_array_json().

populate_array_report_expected_array()

static void populate_array_report_expected_array ( PopulateArrayContext *  ctx, int  ndim  )

static

Definition at line 2410 of file jsonfuncs.c.

{
    if (ndim <= 0)
    {
        if (ctx->colname)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("expected JSON array"),
                     errhint("See the value of key \"%s\".", ctx->colname)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("expected JSON array")));
    }
    else
    {
        StringInfoData indices;
        int         i;
 
        initStringInfo(&indices);
 
        Assert(ctx->ndims > 0 && ndim < ctx->ndims);
 
        for (i = 0; i < ndim; i++)
            appendStringInfo(&indices, "[%d]", ctx->sizes[i]);
 
        if (ctx->