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 "nodes/miscnodes.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 JsonParseErrorType	okeys_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	okeys_array_start (void *state)
static JsonParseErrorType	okeys_scalar (void *state, char *token, JsonTokenType tokentype)
static JsonParseErrorType	get_object_start (void *state)
static JsonParseErrorType	get_object_end (void *state)
static JsonParseErrorType	get_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	get_object_field_end (void *state, char *fname, bool isnull)
static JsonParseErrorType	get_array_start (void *state)
static JsonParseErrorType	get_array_end (void *state)
static JsonParseErrorType	get_array_element_start (void *state, bool isnull)
static JsonParseErrorType	get_array_element_end (void *state, bool isnull)
static JsonParseErrorType	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 JsonParseErrorType	alen_object_start (void *state)
static JsonParseErrorType	alen_scalar (void *state, char *token, JsonTokenType tokentype)
static JsonParseErrorType	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 JsonParseErrorType	each_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	each_object_field_end (void *state, char *fname, bool isnull)
static JsonParseErrorType	each_array_start (void *state)
static JsonParseErrorType	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 JsonParseErrorType	elements_object_start (void *state)
static JsonParseErrorType	elements_array_element_start (void *state, bool isnull)
static JsonParseErrorType	elements_array_element_end (void *state, bool isnull)
static JsonParseErrorType	elements_scalar (void *state, char *token, JsonTokenType tokentype)
static HTAB *	get_json_object_as_hash (char *json, int len, const char *funcname)
static JsonParseErrorType	populate_array_object_start (void *_state)
static JsonParseErrorType	populate_array_array_end (void *_state)
static JsonParseErrorType	populate_array_element_start (void *_state, bool isnull)
static JsonParseErrorType	populate_array_element_end (void *_state, bool isnull)
static JsonParseErrorType	populate_array_scalar (void *_state, char *token, JsonTokenType tokentype)
static JsonParseErrorType	hash_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	hash_object_field_end (void *state, char *fname, bool isnull)
static JsonParseErrorType	hash_array_start (void *state)
static JsonParseErrorType	hash_scalar (void *state, char *token, JsonTokenType tokentype)
static JsonParseErrorType	populate_recordset_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	populate_recordset_object_field_end (void *state, char *fname, bool isnull)
static JsonParseErrorType	populate_recordset_scalar (void *state, char *token, JsonTokenType tokentype)
static JsonParseErrorType	populate_recordset_object_start (void *state)
static JsonParseErrorType	populate_recordset_object_end (void *state)
static JsonParseErrorType	populate_recordset_array_start (void *state)
static JsonParseErrorType	populate_recordset_array_element_start (void *state, bool isnull)
static JsonParseErrorType	sn_object_start (void *state)
static JsonParseErrorType	sn_object_end (void *state)
static JsonParseErrorType	sn_array_start (void *state)
static JsonParseErrorType	sn_array_end (void *state)
static JsonParseErrorType	sn_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	sn_array_element_start (void *state, bool isnull)
static JsonParseErrorType	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 JsonParseErrorType	iterate_values_scalar (void *state, char *token, JsonTokenType tokentype)
static JsonParseErrorType	iterate_values_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	transform_string_values_object_start (void *state)
static JsonParseErrorType	transform_string_values_object_end (void *state)
static JsonParseErrorType	transform_string_values_array_start (void *state)
static JsonParseErrorType	transform_string_values_array_end (void *state)
static JsonParseErrorType	transform_string_values_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	transform_string_values_array_element_start (void *state, bool isnull)
static JsonParseErrorType	transform_string_values_scalar (void *state, char *token, JsonTokenType tokentype)
bool	pg_parse_json_or_errsave (JsonLexContext *lex, JsonSemAction *sem, Node *escontext)
JsonLexContext *	makeJsonLexContext (text *json, bool need_escapes)
Datum	jsonb_object_keys (PG_FUNCTION_ARGS)
void	json_errsave_error (JsonParseErrorType error, JsonLexContext *lex, Node *escontext)
Datum	json_object_keys (PG_FUNCTION_ARGS)
Datum	json_object_field (PG_FUNCTION_ARGS)
Datum	jsonb_object_field (PG_FUNCTION_ARGS)
Datum	json_object_field_text (PG_FUNCTION_ARGS)
Datum	jsonb_object_field_text (PG_FUNCTION_ARGS)
Datum	json_array_element (PG_FUNCTION_ARGS)
Datum	jsonb_array_element (PG_FUNCTION_ARGS)
Datum	json_array_element_text (PG_FUNCTION_ARGS)
Datum	jsonb_array_element_text (PG_FUNCTION_ARGS)
Datum	json_extract_path (PG_FUNCTION_ARGS)
Datum	json_extract_path_text (PG_FUNCTION_ARGS)
Datum	jsonb_extract_path (PG_FUNCTION_ARGS)
Datum	jsonb_extract_path_text (PG_FUNCTION_ARGS)
Datum	jsonb_get_element (Jsonb *jb, Datum *path, int npath, bool *isnull, bool as_text)
Datum	jsonb_set_element (Jsonb *jb, Datum *path, int path_len, JsonbValue *newval)
static void	push_null_elements (JsonbParseState **ps, int num)
static void	push_path (JsonbParseState **st, int level, Datum *path_elems, bool *path_nulls, int path_len, JsonbValue *newval)
Datum	json_array_length (PG_FUNCTION_ARGS)
Datum	jsonb_array_length (PG_FUNCTION_ARGS)
Datum	json_each (PG_FUNCTION_ARGS)
Datum	jsonb_each (PG_FUNCTION_ARGS)
Datum	json_each_text (PG_FUNCTION_ARGS)
Datum	jsonb_each_text (PG_FUNCTION_ARGS)
Datum	jsonb_array_elements (PG_FUNCTION_ARGS)
Datum	jsonb_array_elements_text (PG_FUNCTION_ARGS)
Datum	json_array_elements (PG_FUNCTION_ARGS)
Datum	json_array_elements_text (PG_FUNCTION_ARGS)
Datum	jsonb_populate_record (PG_FUNCTION_ARGS)
Datum	jsonb_to_record (PG_FUNCTION_ARGS)
Datum	json_populate_record (PG_FUNCTION_ARGS)
Datum	json_to_record (PG_FUNCTION_ARGS)
static void	update_cached_tupdesc (CompositeIOData *io, MemoryContext mcxt)
Datum	jsonb_populate_recordset (PG_FUNCTION_ARGS)
Datum	jsonb_to_recordset (PG_FUNCTION_ARGS)
Datum	json_populate_recordset (PG_FUNCTION_ARGS)
Datum	json_to_recordset (PG_FUNCTION_ARGS)
Datum	json_strip_nulls (PG_FUNCTION_ARGS)
Datum	jsonb_strip_nulls (PG_FUNCTION_ARGS)
Datum	jsonb_pretty (PG_FUNCTION_ARGS)
Datum	jsonb_concat (PG_FUNCTION_ARGS)
Datum	jsonb_delete (PG_FUNCTION_ARGS)
Datum	jsonb_delete_array (PG_FUNCTION_ARGS)
Datum	jsonb_delete_idx (PG_FUNCTION_ARGS)
Datum	jsonb_set (PG_FUNCTION_ARGS)
Datum	jsonb_set_lax (PG_FUNCTION_ARGS)
Datum	jsonb_delete_path (PG_FUNCTION_ARGS)
Datum	jsonb_insert (PG_FUNCTION_ARGS)
uint32	parse_jsonb_index_flags (Jsonb *jb)
void	iterate_jsonb_values (Jsonb *jb, uint32 flags, void *state, JsonIterateStringValuesAction action)
void	iterate_json_values (text *json, uint32 flags, void *action_state, JsonIterateStringValuesAction action)
Jsonb *	transform_jsonb_string_values (Jsonb *jsonb, void *action_state, JsonTransformStringValuesAction transform_action)
text *	transform_json_string_values (text *json, void *action_state, JsonTransformStringValuesAction transform_action)

Macro Definition Documentation

JB_PATH_CONSISTENT_POSITION

#define JB_PATH_CONSISTENT_POSITION   0x0040

Definition at line 50 of file jsonfuncs.c.

JB_PATH_CREATE

#define JB_PATH_CREATE   0x0001

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

JB_PATH_DELETE

#define JB_PATH_DELETE   0x0002

Definition at line 43 of file jsonfuncs.c.

JB_PATH_FILL_GAPS

#define JB_PATH_FILL_GAPS   0x0020

Definition at line 49 of file jsonfuncs.c.

JB_PATH_INSERT_AFTER

#define JB_PATH_INSERT_AFTER   0x0010

Definition at line 46 of file jsonfuncs.c.

JB_PATH_INSERT_BEFORE

#define JB_PATH_INSERT_BEFORE   0x0008

Definition at line 45 of file jsonfuncs.c.

JB_PATH_REPLACE

#define JB_PATH_REPLACE   0x0004

Definition at line 44 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 331 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 325 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 316 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 321 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 197 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 JsonParseErrorType alen_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 1918 of file jsonfuncs.c.

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

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

Referenced by json_array_length().

alen_object_start()

static JsonParseErrorType alen_object_start ( void *  state )

static

Definition at line 1890 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")));
 
    return JSON_SUCCESS;
}

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

Referenced by json_array_length().

alen_scalar()

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

static

Definition at line 1904 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")));
 
    return JSON_SUCCESS;
}

References ereport, errcode(), errmsg(), ERROR, JSON_SUCCESS, 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 3219 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(), and MemSet.

Referenced by populate_record().

each_array_start()

static JsonParseErrorType each_array_start ( void *  state )

static

Definition at line 2158 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")));
 
    return JSON_SUCCESS;
}

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

Referenced by each_worker().

each_object_field_end()

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

static

Definition at line 2110 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 JSON_SUCCESS;
 
    /* 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);
 
    return JSON_SUCCESS;
}

References cstring_to_text_with_len(), CStringGetTextDatum, heap_form_tuple(), JSON_SUCCESS, 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 JsonParseErrorType each_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 2088 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;
    }
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, 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 JsonParseErrorType each_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 2172 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;
 
    return JSON_SUCCESS;
}

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

Referenced by each_worker().

each_worker()

static Datum each_worker ( FunctionCallInfo  fcinfo, bool  as_text  )

static

Definition at line 2048 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;
 
    InitMaterializedSRF(fcinfo, MAT_SRF_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(), InitMaterializedSRF(), makeJsonLexContext(), MAT_SRF_BLESS, 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, and ReturnSetInfo::setResult.

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 1964 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;
    InitMaterializedSRF(fcinfo, MAT_SRF_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, funcname, InitMaterializedSRF(), JB_ROOT_IS_OBJECT, jbvNull, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueAsText(), JsonbValueToJsonb(), sort-test::key, MAT_SRF_BLESS, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), PG_GETARG_JSONB_P, PG_RETURN_NULL, PointerGetDatum(), FunctionCallInfoBaseData::resultinfo, Jsonb::root, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, 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 JsonParseErrorType elements_array_element_end ( void *  state, bool  isnull  )

static

Definition at line 2360 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 JSON_SUCCESS;
 
    /* 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);
 
    return JSON_SUCCESS;
}

References cstring_to_text_with_len(), CStringGetTextDatum, heap_form_tuple(), JSON_SUCCESS, 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 JsonParseErrorType elements_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 2338 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;
    }
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, 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 JsonParseErrorType elements_object_start ( void *  state )

static

Definition at line 2406 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)));
 
    return JSON_SUCCESS;
}

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

Referenced by elements_worker().

elements_scalar()

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

static

Definition at line 2421 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;
 
    return JSON_SUCCESS;
}

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

Referenced by elements_worker().

elements_worker()

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

static

Definition at line 2298 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));
 
    InitMaterializedSRF(fcinfo, MAT_SRF_USE_EXPECTED_DESC | MAT_SRF_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(), funcname, InitMaterializedSRF(), makeJsonLexContext(), MAT_SRF_BLESS, MAT_SRF_USE_EXPECTED_DESC, 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, and ReturnSetInfo::setResult.

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 2210 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;
 
    InitMaterializedSRF(fcinfo, MAT_SRF_USE_EXPECTED_DESC | MAT_SRF_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, InitMaterializedSRF(), JB_ROOT_IS_ARRAY, JB_ROOT_IS_SCALAR, jbvNull, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueAsText(), JsonbValueToJsonb(), MAT_SRF_BLESS, MAT_SRF_USE_EXPECTED_DESC, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), PG_GETARG_JSONB_P, PG_RETURN_NULL, PointerGetDatum(), FunctionCallInfoBaseData::resultinfo, Jsonb::root, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, 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 JsonParseErrorType get_array_element_end ( void *  state, bool  isnull  )

static

Definition at line 1389 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;
    }
 
    return JSON_SUCCESS;
}

References GetState::array_cur_index, cstring_to_text_with_len(), JSON_SUCCESS, 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 JsonParseErrorType get_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 1341 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;
        }
    }
 
    return JSON_SUCCESS;
}

References GetState::array_cur_index, JSON_SUCCESS, 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 JsonParseErrorType get_array_end ( void *  state )

static

Definition at line 1323 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);
    }
 
    return JSON_SUCCESS;
}

References cstring_to_text_with_len(), JSON_SUCCESS, 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 JsonParseErrorType get_array_start ( void *  state )

static

Definition at line 1283 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_errsave_error(error, _state->lex, NULL);
 
            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;
    }
 
    return JSON_SUCCESS;
}

References GetState::array_cur_index, error(), json_count_array_elements(), json_errsave_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 3544 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, funcname, 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 1488 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_builtin(path, TEXTOID, &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_builtin(), 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 JsonParseErrorType get_object_end ( void *  state )

static

Definition at line 1167 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);
    }
 
    return JSON_SUCCESS;
}

References cstring_to_text_with_len(), JSON_SUCCESS, 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 JsonParseErrorType get_object_field_end ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 1232 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;
    }
 
    return JSON_SUCCESS;
}

References cstring_to_text_with_len(), JSON_SUCCESS, 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 JsonParseErrorType get_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 1185 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;
        }
    }
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, 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 JsonParseErrorType get_object_start ( void *  state )

static

Definition at line 1148 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;
    }
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, 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 1013 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_builtin(path, TEXTOID, &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_builtin(), 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 3376 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, funcname, 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 3402 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(), funcname, 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 JsonParseErrorType get_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 1433 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;
    }
 
    return JSON_SUCCESS;
}

References cstring_to_text(), cstring_to_text_with_len(), JsonLexContext::input, JSON_SUCCESS, JSON_TOKEN_NULL, JSON_TOKEN_STRING, len, GetState::lex, JsonLexContext::lex_level, GetState::next_scalar, GetState::normalize_results, GetState::npath, JsonLexContext::prev_token_terminator, token, 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 1092 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 JsonParseErrorType hash_array_start ( void *  state )

static

Definition at line 3656 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)));
 
    return JSON_SUCCESS;
}

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

Referenced by get_json_object_as_hash().

hash_object_field_end()

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

static

Definition at line 3605 of file jsonfuncs.c.

{
    JHashState *_state = (JHashState *) state;
    JsonHashEntry *hashentry;
    bool        found;
 
    /*
     * Ignore nested fields.
     */
    if (_state->lex->lex_level > 1)
        return JSON_SUCCESS;
 
    /*
     * 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 JSON_SUCCESS;
 
    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;
    }
 
    return JSON_SUCCESS;
}

References Assert(), JHashState::hash, HASH_ENTER, hash_search(), JSON_SUCCESS, 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 JsonParseErrorType hash_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 3579 of file jsonfuncs.c.

{
    JHashState *_state = (JHashState *) state;
 
    if (_state->lex->lex_level > 1)
        return JSON_SUCCESS;
 
    /* 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;
    }
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, 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 JsonParseErrorType hash_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 3669 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);
    }
 
    return JSON_SUCCESS;
}

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

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 5432 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 5364 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 JsonParseErrorType iterate_values_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 5484 of file jsonfuncs.c.

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

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

Referenced by iterate_json_values().

iterate_values_scalar()

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

static

Definition at line 5456 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;
    }
 
    return JSON_SUCCESS;
}

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

Referenced by iterate_json_values().

IteratorConcat()

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

static

Definition at line 4776 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 3235 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 911 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 954 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 2286 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 2292 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 1840 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 1940 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 1952 of file jsonfuncs.c.

{
    return each_worker(fcinfo, true);
}

References each_worker().

json_errsave_error()

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

Definition at line 628 of file jsonfuncs.c.

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

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

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

json_extract_path()

Datum json_extract_path

(

PG_FUNCTION_ARGS

)

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

{
    return get_path_all(fcinfo, true);
}

References get_path_all().

json_object_field()

Datum json_object_field

(

PG_FUNCTION_ARGS

)

Definition at line 835 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 873 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 719 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 2466 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 3714 of file jsonfuncs.c.

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

References populate_recordset_worker().

json_strip_nulls()

Datum json_strip_nulls

(

PG_FUNCTION_ARGS

)

Definition at line 4215 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 2473 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 3721 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 926 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 969 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 2198 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 2204 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 1868 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 4323 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 4364 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 4417 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_builtin(keys, TEXTOID, &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;
 
                /* We rely on the array elements not being toasted */
                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_builtin(), 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 4504 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 4684 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_builtin(path, TEXTOID, &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_builtin(), 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 1946 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 1958 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 1476 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 1482 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 1519 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)
        {
            text       *subscr = DatumGetTextPP(path[i]);
 
            jbvp = getKeyJsonValueFromContainer(container,
                                                VARDATA_ANY(subscr),
                                                VARSIZE_ANY_EXHDR(subscr),
                                                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(), DatumGetTextPP, 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_ANY, VARSIZE, and VARSIZE_ANY_EXHDR.

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 4727 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_builtin(path, TEXTOID, &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_builtin(), 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 851 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 889 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 555 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 2452 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 3700 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 4307 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 4568 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_builtin(path, TEXTOID, &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_builtin(), 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 1667 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 4617 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 4249 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 2459 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 3707 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 1793 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 2848 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 528 of file jsonfuncs.c.

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

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

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

okeys_array_start()

static JsonParseErrorType okeys_array_start ( void *  state )

static

Definition at line 798 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")));
 
    return JSON_SUCCESS;
}

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

Referenced by json_object_keys().

okeys_object_field_start()

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

static

Definition at line 775 of file jsonfuncs.c.

{
    OkeysState *_state = (OkeysState *) state;
 
    /* only collecting keys for the top level object */
    if (_state->lex->lex_level != 1)
        return JSON_SUCCESS;
 
    /* 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);
 
    return JSON_SUCCESS;
}

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

Referenced by json_object_keys().

okeys_scalar()

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

static

Definition at line 813 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")));
 
    return JSON_SUCCESS;
}

References ereport, errcode(), errmsg(), ERROR, JSON_SUCCESS, 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 5296 of file jsonfuncs.c.

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

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

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

pg_parse_json_or_errsave()

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

Definition at line 507 of file jsonfuncs.c.

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

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

Referenced by json_in(), and jsonb_from_cstring().

populate_array()

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

static

Definition at line 2801 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 JsonParseErrorType populate_array_array_end ( void *  _state )

static

Definition at line 2601 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);
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS, 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 2524 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 2543 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 2730 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))
        populate_array_report_expected_array(ctx, ndim - 1);
 
    Assert(!JsonContainerIsScalar(jbc));
 
    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 2565 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 JsonParseErrorType populate_array_element_end ( void *  _state, bool  isnull  )

static

Definition at line 2636 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);
    }
 
    return JSON_SUCCESS;
}

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

Referenced by populate_array_json().

populate_array_element_start()

static JsonParseErrorType populate_array_element_start ( void *  _state, bool  isnull  )

static

Definition at line 2618 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;
    }
 
    return JSON_SUCCESS;
}

References JSON_SUCCESS.

Referenced by populate_array_json().

populate_array_json()

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

static

Definition at line 2701 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::