jsonfuncs.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/htup_details.h"
#include "catalog/pg_type.h"
#include "common/int.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 "parser/parse_coerce.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 (const char *json, int len, const char *funcname, Node *escontext)
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, Node *escontext)
static HeapTupleHeader	populate_record (TupleDesc tupdesc, RecordIOData **record_p, HeapTupleHeader defaultval, MemoryContext mcxt, JsObject *obj, Node *escontext)
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 bool	JsValueToJsObject (JsValue *jsv, JsObject *jso, Node *escontext)
static Datum	populate_composite (CompositeIOData *io, Oid typid, const char *colname, MemoryContext mcxt, HeapTupleHeader defaultval, JsValue *jsv, bool *isnull, Node *escontext)
static Datum	populate_scalar (ScalarIOData *io, Oid typid, int32 typmod, JsValue *jsv, bool *isnull, Node *escontext, bool omit_quotes)
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, Node *escontext, bool omit_scalar_quotes)
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 bool	populate_array_json (PopulateArrayContext *ctx, const char *json, int len)
static bool	populate_array_dim_jsonb (PopulateArrayContext *ctx, JsonbValue *jbv, int ndim)
static void	populate_array_report_expected_array (PopulateArrayContext *ctx, int ndim)
static bool	populate_array_assign_ndims (PopulateArrayContext *ctx, int ndims)
static bool	populate_array_check_dimension (PopulateArrayContext *ctx, int ndim)
static bool	populate_array_element (PopulateArrayContext *ctx, int ndim, JsValue *jsv)
static Datum	populate_array (ArrayIOData *aio, const char *colname, MemoryContext mcxt, JsValue *jsv, bool *isnull, Node *escontext)
static Datum	populate_domain (DomainIOData *io, Oid typid, const char *colname, MemoryContext mcxt, JsValue *jsv, bool *isnull, Node *escontext, bool omit_quotes)
static void	IteratorConcat (JsonbIterator **it1, JsonbIterator **it2, JsonbInState *state)
static void	setPath (JsonbIterator **it, const Datum *path_elems, const bool *path_nulls, int path_len, JsonbInState *st, int level, JsonbValue *newval, int op_type)
static void	setPathObject (JsonbIterator **it, const Datum *path_elems, const bool *path_nulls, int path_len, JsonbInState *st, int level, JsonbValue *newval, uint32 npairs, int op_type)
static void	setPathArray (JsonbIterator **it, const Datum *path_elems, const bool *path_nulls, int path_len, JsonbInState *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, const JsonSemAction *sem, Node *escontext)
JsonLexContext *	makeJsonLexContext (JsonLexContext *lex, 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, const Datum *path, int npath, bool *isnull, bool as_text)
Datum	jsonb_set_element (Jsonb *jb, const Datum *path, int path_len, JsonbValue *newval)
static void	push_null_elements (JsonbInState *ps, int num)
static void	push_path (JsonbInState *st, int level, const Datum *path_elems, const 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_populate_record_valid (PG_FUNCTION_ARGS)
Datum	jsonb_to_record (PG_FUNCTION_ARGS)
Datum	json_populate_record (PG_FUNCTION_ARGS)
Datum	json_to_record (PG_FUNCTION_ARGS)
static void	update_cached_tupdesc (CompositeIOData *io, MemoryContext mcxt)
Datum	json_populate_type (Datum json_val, Oid json_type, Oid typid, int32 typmod, void **cache, MemoryContext mcxt, bool *isnull, bool omit_quotes, Node *escontext)
Datum	jsonb_populate_recordset (PG_FUNCTION_ARGS)
Datum	jsonb_to_recordset (PG_FUNCTION_ARGS)
Datum	json_populate_recordset (PG_FUNCTION_ARGS)
Datum	json_to_recordset (PG_FUNCTION_ARGS)
Datum	json_strip_nulls (PG_FUNCTION_ARGS)
Datum	jsonb_strip_nulls (PG_FUNCTION_ARGS)
Datum	jsonb_pretty (PG_FUNCTION_ARGS)
Datum	jsonb_concat (PG_FUNCTION_ARGS)
Datum	jsonb_delete (PG_FUNCTION_ARGS)
Datum	jsonb_delete_array (PG_FUNCTION_ARGS)
Datum	jsonb_delete_idx (PG_FUNCTION_ARGS)
Datum	jsonb_set (PG_FUNCTION_ARGS)
Datum	jsonb_set_lax (PG_FUNCTION_ARGS)
Datum	jsonb_delete_path (PG_FUNCTION_ARGS)
Datum	jsonb_insert (PG_FUNCTION_ARGS)
uint32	parse_jsonb_index_flags (Jsonb *jb)
void	iterate_jsonb_values (Jsonb *jb, uint32 flags, void *state, JsonIterateStringValuesAction action)
void	iterate_json_values (text *json, uint32 flags, void *action_state, JsonIterateStringValuesAction action)
Jsonb *	transform_jsonb_string_values (Jsonb *jsonb, void *action_state, JsonTransformStringValuesAction transform_action)
text *	transform_json_string_values (text *json, void *action_state, JsonTransformStringValuesAction transform_action)
JsonTokenType	json_get_first_token (text *json, bool throw_error)
void	json_categorize_type (Oid typoid, bool is_jsonb, JsonTypeCategory *tcategory, Oid *outfuncoid)

Macro Definition Documentation

JB_PATH_CONSISTENT_POSITION

#define JB_PATH_CONSISTENT_POSITION   0x0040

Definition at line 52 of file jsonfuncs.c.

JB_PATH_CREATE

#define JB_PATH_CREATE   0x0001

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

JB_PATH_DELETE

#define JB_PATH_DELETE   0x0002

Definition at line 45 of file jsonfuncs.c.

JB_PATH_FILL_GAPS

#define JB_PATH_FILL_GAPS   0x0020

Definition at line 51 of file jsonfuncs.c.

JB_PATH_INSERT_AFTER

#define JB_PATH_INSERT_AFTER   0x0010

Definition at line 48 of file jsonfuncs.c.

JB_PATH_INSERT_BEFORE

#define JB_PATH_INSERT_BEFORE   0x0008

Definition at line 47 of file jsonfuncs.c.

JB_PATH_REPLACE

#define JB_PATH_REPLACE   0x0004

Definition at line 46 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 335 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 329 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 320 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 325 of file jsonfuncs.c.

Typedef Documentation

AlenState

typedef struct AlenState AlenState

ArrayIOData

typedef struct ArrayIOData ArrayIOData

ColumnIOData

typedef struct ColumnIOData ColumnIOData

Definition at line 162 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 163 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 199 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 1925 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 1897 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 1911 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 3473 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 2165 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 2117 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 2095 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 2179 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 2055 of file jsonfuncs.c.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    JsonLexContext lex;
    JsonSemAction *sem;
    ReturnSetInfo *rsi;
    EachState  *state;
 
    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 = 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 = makeJsonLexContext(&lex, json, true);
    state->tmp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                           "json_each temporary cxt",
                                           ALLOCSET_DEFAULT_SIZES);
 
    pg_parse_json_or_ereport(&lex, sem);
 
    MemoryContextDelete(state->tmp_cxt);
    freeJsonLexContext(&lex);
 
    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(), freeJsonLexContext(), 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, sem, 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 1971 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) 0;
                }
                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 2369 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) 0;
    }
    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 2347 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 2415 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 2430 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 2305 of file jsonfuncs.c.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    JsonLexContext lex;
    JsonSemAction *sem;
    ReturnSetInfo *rsi;
    ElementsState *state;
 
    /* elements only needs escaped strings when as_text */
    makeJsonLexContext(&lex, json, as_text);
 
    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 = 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);
    freeJsonLexContext(&lex);
 
    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(), freeJsonLexContext(), 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, sem, 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 2217 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) 0;
                }
                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 1401 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
        {
            const 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, 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 1353 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 1335 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 */
        const 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, start, and GetState::tresult.

Referenced by get_worker().

get_array_start()

static JsonParseErrorType get_array_start ( void *  state )

static

Definition at line 1295 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 ( const char *  json, int  len, const char *  funcname, Node *  escontext  )

static

Definition at line 3808 of file jsonfuncs.c.

{
    HASHCTL     ctl;
    HTAB       *tab;
    JHashState *state;
    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 = makeJsonLexContextCstringLen(NULL, json, len,
                                              GetDatabaseEncoding(), true);
 
    sem->semstate = 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;
 
    if (!pg_parse_json_or_errsave(state->lex, sem, escontext))
    {
        hash_destroy(state->hash);
        tab = NULL;
    }
 
    freeJsonLexContext(state->lex);
 
    return tab;
}

References JsonSemAction::array_start, ctl, CurrentMemoryContext, freeJsonLexContext(), funcname, GetDatabaseEncoding(), hash_array_start(), HASH_CONTEXT, hash_create(), hash_destroy(), HASH_ELEM, hash_object_field_end(), hash_object_field_start(), hash_scalar(), HASH_STRINGS, len, makeJsonLexContextCstringLen(), NAMEDATALEN, JsonSemAction::object_field_end, JsonSemAction::object_field_start, palloc0(), pg_parse_json_or_errsave(), JsonSemAction::scalar, sem, 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 1500 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, and PG_RETURN_NULL.

Referenced by jsonb_extract_path(), and jsonb_extract_path_text().

get_object_end()

static JsonParseErrorType get_object_end ( void *  state )

static

Definition at line 1179 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 */
        const 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, 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 1244 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
        {
            const 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, 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 1197 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 1160 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 1024 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 3633 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 3659 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 1445 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.
             */
            const 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, start, 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 1103 of file jsonfuncs.c.

{
    JsonSemAction *sem = palloc0(sizeof(JsonSemAction));
    GetState   *state = palloc0(sizeof(GetState));
 
    Assert(npath >= 0);
 
    state->lex = makeJsonLexContext(NULL, json, true);
 
    /* 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 = 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(state->lex, sem);
    freeJsonLexContext(state->lex);
 
    return state->tresult;
}

References JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, Assert(), freeJsonLexContext(), 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, sem, 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 3927 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 3876 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 3850 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 3940 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 5699 of file jsonfuncs.c.

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

References generate_unaccent_rules::action, freeJsonLexContext(), iterate_values_object_field_start(), iterate_values_scalar(), makeJsonLexContext(), JsonSemAction::object_field_start, palloc0(), pg_parse_json_or_ereport, JsonSemAction::scalar, sem, 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 5631 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, 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 5752 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 5724 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, and jtiString.

Referenced by iterate_json_values().

IteratorConcat()

static void IteratorConcat ( JsonbIterator **  it1, JsonbIterator **  it2, JsonbInState *  state  )

static

Definition at line 5052 of file jsonfuncs.c.

{
    JsonbValue  v1,
                v2;
    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)
            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);
        }
 
        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)
            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);
 
        pushJsonbValue(state, WJB_END_ARRAY, NULL);
    }
}

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

Referenced by jsonb_concat().

JsObjectGetField()

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

static

Definition at line 3489 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, JsValue::len, JsValue::str, JsonHashEntry::type, JsValue::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 922 of file jsonfuncs.c.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    int         element = PG_GETARG_INT32(1);
    text       *result;
 
    result = get_worker(json, NULL, &element, 1, 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 965 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 2293 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 2299 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 1849 of file jsonfuncs.c.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    AlenState  *state;
    JsonLexContext lex;
    JsonSemAction *sem;
 
    state = palloc0(sizeof(AlenState));
    state->lex = makeJsonLexContext(&lex, json, false);
    /* palloc0 does this for us */
#if 0
    state->count = 0;
#endif
 
    sem = palloc0(sizeof(JsonSemAction));
    sem->semstate = state;
    sem->object_start = alen_object_start;
    sem->scalar = alen_scalar;
    sem->array_element_start = alen_array_element_start;
 
    pg_parse_json_or_ereport(state->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, sem, and JsonSemAction::semstate.

json_categorize_type()

void json_categorize_type	(	Oid	typoid,
		bool	is_jsonb,
		JsonTypeCategory *	tcategory,
		Oid *	outfuncoid
	)

Definition at line 5968 of file jsonfuncs.c.

{
    bool        typisvarlena;
 
    /* Look through any domain */
    typoid = getBaseType(typoid);
 
    *outfuncoid = InvalidOid;
 
    switch (typoid)
    {
        case BOOLOID:
            *outfuncoid = F_BOOLOUT;
            *tcategory = JSONTYPE_BOOL;
            break;
 
        case INT2OID:
        case INT4OID:
        case INT8OID:
        case FLOAT4OID:
        case FLOAT8OID:
        case NUMERICOID:
            getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
            *tcategory = JSONTYPE_NUMERIC;
            break;
 
        case DATEOID:
            *outfuncoid = F_DATE_OUT;
            *tcategory = JSONTYPE_DATE;
            break;
 
        case TIMESTAMPOID:
            *outfuncoid = F_TIMESTAMP_OUT;
            *tcategory = JSONTYPE_TIMESTAMP;
            break;
 
        case TIMESTAMPTZOID:
            *outfuncoid = F_TIMESTAMPTZ_OUT;
            *tcategory = JSONTYPE_TIMESTAMPTZ;
            break;
 
        case JSONOID:
            getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
            *tcategory = JSONTYPE_JSON;
            break;
 
        case JSONBOID:
            getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
            *tcategory = is_jsonb ? JSONTYPE_JSONB : JSONTYPE_JSON;
            break;
 
        default:
            /* Check for arrays and composites */
            if (OidIsValid(get_element_type(typoid)) || typoid == ANYARRAYOID
                || typoid == ANYCOMPATIBLEARRAYOID || typoid == RECORDARRAYOID)
            {
                *outfuncoid = F_ARRAY_OUT;
                *tcategory = JSONTYPE_ARRAY;
            }
            else if (type_is_rowtype(typoid))   /* includes RECORDOID */
            {
                *outfuncoid = F_RECORD_OUT;
                *tcategory = JSONTYPE_COMPOSITE;
            }
            else
            {
                /*
                 * It's probably the general case.  But let's look for a cast
                 * to json (note: not to jsonb even if is_jsonb is true), if
                 * it's not built-in.
                 */
                *tcategory = JSONTYPE_OTHER;
                if (typoid >= FirstNormalObjectId)
                {
                    Oid         castfunc;
                    CoercionPathType ctype;
 
                    ctype = find_coercion_pathway(JSONOID, typoid,
                                                  COERCION_EXPLICIT,
                                                  &castfunc);
                    if (ctype == COERCION_PATH_FUNC && OidIsValid(castfunc))
                    {
                        *outfuncoid = castfunc;
                        *tcategory = JSONTYPE_CAST;
                    }
                    else
                    {
                        /* non builtin type with no cast */
                        getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
                    }
                }
                else
                {
                    /* any other builtin type */
                    getTypeOutputInfo(typoid, outfuncoid, &typisvarlena);
                }
            }
            break;
    }
}

References COERCION_EXPLICIT, COERCION_PATH_FUNC, find_coercion_pathway(), FirstNormalObjectId, get_element_type(), getBaseType(), getTypeOutputInfo(), InvalidOid, JSONTYPE_ARRAY, JSONTYPE_BOOL, JSONTYPE_CAST, JSONTYPE_COMPOSITE, JSONTYPE_DATE, JSONTYPE_JSON, JSONTYPE_JSONB, JSONTYPE_NUMERIC, JSONTYPE_OTHER, JSONTYPE_TIMESTAMP, JSONTYPE_TIMESTAMPTZ, OidIsValid, and type_is_rowtype().

Referenced by add_json(), add_jsonb(), array_to_json_internal(), array_to_jsonb_internal(), composite_to_json(), composite_to_jsonb(), ExecInitExprRec(), json_agg_transfn_worker(), json_object_agg_transfn_worker(), jsonb_agg_transfn_worker(), jsonb_object_agg_transfn_worker(), to_json(), to_json_is_immutable(), to_jsonb(), and to_jsonb_is_immutable().

json_each()

Datum json_each

(

PG_FUNCTION_ARGS

)

Definition at line 1947 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 1959 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 641 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_get_first_token(), json_typeof(), json_validate(), and pg_parse_json_or_errsave().

json_extract_path()

Datum json_extract_path

(

PG_FUNCTION_ARGS

)

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

{
    return get_path_all(fcinfo, true);
}

References get_path_all().

json_get_first_token()

JsonTokenType json_get_first_token	(	text *	json,
		bool	throw_error
	)

Definition at line 5941 of file jsonfuncs.c.

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

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

Referenced by ExecEvalJsonIsPredicate().

json_object_field()

Datum json_object_field

(

PG_FUNCTION_ARGS

)

Definition at line 846 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 884 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 732 of file jsonfuncs.c.

{
    FuncCallContext *funcctx;
    OkeysState *state;
 
    if (SRF_IS_FIRSTCALL())
    {
        text       *json = PG_GETARG_TEXT_PP(0);
        JsonLexContext lex;
        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 = makeJsonLexContext(&lex, json, true);
        state->result_size = 256;
        state->result_count = 0;
        state->sent_count = 0;
        state->result = palloc(256 * sizeof(char *));
 
        sem->semstate = 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 */
 
        freeJsonLexContext(&lex);
        pfree(sem);
 
        MemoryContextSwitchTo(oldcontext);
        funcctx->user_fctx = 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, freeJsonLexContext(), 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, sem, JsonSemAction::semstate, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and FuncCallContext::user_fctx.

json_populate_record()

Datum json_populate_record

(

PG_FUNCTION_ARGS

)

Definition at line 2492 of file jsonfuncs.c.

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

References populate_record_worker().

json_populate_recordset()

Datum json_populate_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3985 of file jsonfuncs.c.

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

References populate_recordset_worker().

json_populate_type()

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

Definition at line 3342 of file jsonfuncs.c.

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

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

Referenced by ExecEvalJsonCoercion().

json_strip_nulls()

Datum json_strip_nulls

(

PG_FUNCTION_ARGS

)

Definition at line 4502 of file jsonfuncs.c.

{
    text       *json = PG_GETARG_TEXT_PP(0);
    bool        strip_in_arrays = PG_NARGS() == 2 ? PG_GETARG_BOOL(1) : false;
    StripnullState *state;
    StringInfoData strbuf;
    JsonLexContext lex;
    JsonSemAction *sem;
 
    state = palloc0(sizeof(StripnullState));
    sem = palloc0(sizeof(JsonSemAction));
    initStringInfo(&strbuf);
 
    state->lex = makeJsonLexContext(&lex, json, true);
    state->strval = &strbuf;
    state->skip_next_null = false;
    state->strip_in_arrays = strip_in_arrays;
 
    sem->semstate = 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(), initStringInfo(), makeJsonLexContext(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc0(), PG_GETARG_BOOL, PG_GETARG_TEXT_PP, PG_NARGS, pg_parse_json_or_ereport, PG_RETURN_TEXT_P, JsonSemAction::scalar, sem, 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 2499 of file jsonfuncs.c.

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

References populate_record_worker().

json_to_recordset()

Datum json_to_recordset

(

PG_FUNCTION_ARGS

)

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

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    int         element = PG_GETARG_INT32(1);
    JsonbValue *v;
 
    if (!JB_ROOT_IS_ARRAY(jb))
        PG_RETURN_NULL();
 
    /* Handle negative subscript */
    if (element < 0)
    {
        uint32      nelements = JB_ROOT_COUNT(jb);
 
        if (pg_abs_s32(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_abs_s32(), 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 980 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 (pg_abs_s32(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_abs_s32(), 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 2205 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 2211 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 1875 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 4620 of file jsonfuncs.c.

{
    Jsonb      *jb1 = PG_GETARG_JSONB_P(0);
    Jsonb      *jb2 = PG_GETARG_JSONB_P(1);
    JsonbInState state = {0};
    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);
 
    IteratorConcat(&it1, &it2, &state);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(state.result));
}

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

jsonb_delete()

Datum jsonb_delete

(

PG_FUNCTION_ARGS

)

Definition at line 4658 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);
    JsonbInState pstate = {0};
    JsonbIterator *it;
    JsonbValue  v;
    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;
        }
 
        pushJsonbValue(&pstate, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
    }
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(pstate.result));
}

References 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(), JsonbInState::result, 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 4708 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;
    JsonbInState pstate = {0};
    JsonbIterator *it;
    JsonbValue  v;
    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(DatumGetPointer(keys_elems[i]));
                keylen = VARSIZE_ANY_EXHDR(DatumGetPointer(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;
            }
        }
 
        pushJsonbValue(&pstate, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
    }
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(pstate.result));
}

References ARR_NDIM, DatumGetPointer(), 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(), JsonbInState::result, 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 4792 of file jsonfuncs.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    int         idx = PG_GETARG_INT32(1);
    JsonbInState pstate = {0};
    JsonbIterator *it;
    uint32      i = 0,
                n;
    JsonbValue  v;
    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 (pg_abs_s32(idx) > n)
            idx = n;
        else
            idx = n + idx;
    }
 
    if (idx >= n)
        PG_RETURN_JSONB_P(in);
 
    pushJsonbValue(&pstate, r, NULL);
 
    while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
    {
        if (r == WJB_ELEM)
        {
            if (i++ == idx)
                continue;
        }
 
        pushJsonbValue(&pstate, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
    }
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(pstate.result));
}

References Assert(), ereport, errcode(), errmsg(), ERROR, i, idx(), JB_ROOT_COUNT, JB_ROOT_IS_OBJECT, JB_ROOT_IS_SCALAR, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), pg_abs_s32(), PG_GETARG_INT32, PG_GETARG_JSONB_P, PG_RETURN_JSONB_P, pushJsonbValue(), JsonbInState::result, 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 4966 of file jsonfuncs.c.

{
    Jsonb      *in = PG_GETARG_JSONB_P(0);
    ArrayType  *path = PG_GETARG_ARRAYTYPE_P(1);
    Datum      *path_elems;
    bool       *path_nulls;
    int         path_len;
    JsonbIterator *it;
    JsonbInState st = {0};
 
    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);
 
    setPath(&it, path_elems, path_nulls, path_len, &st,
            0, NULL, JB_PATH_DELETE);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(st.result));
}

References ARR_NDIM, 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, JsonbInState::result, Jsonb::root, and setPath().

Referenced by jsonb_set_lax().

jsonb_each()

Datum jsonb_each

(

PG_FUNCTION_ARGS

)

Definition at line 1953 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 1965 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 1488 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 1494 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,
		const Datum *	path,
		int	npath,
		bool *	isnull,
		bool	as_text
	)

Definition at line 1531 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(), 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 5006 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);
    Datum      *path_elems;
    bool       *path_nulls;
    int         path_len;
    JsonbIterator *it;
    JsonbInState st = {0};
 
    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);
 
    setPath(&it, path_elems, path_nulls, path_len, &st, 0, &newval,
            after ? JB_PATH_INSERT_AFTER : JB_PATH_INSERT_BEFORE);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(st.result));
}

References ARR_NDIM, 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, JsonbInState::result, Jsonb::root, and setPath().

jsonb_object_field()

Datum jsonb_object_field

(

PG_FUNCTION_ARGS

)

Definition at line 862 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 900 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 568 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 = 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 2461 of file jsonfuncs.c.

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

References populate_record_worker().

jsonb_populate_record_valid()

Datum jsonb_populate_record_valid

(

PG_FUNCTION_ARGS

)

Definition at line 2474 of file jsonfuncs.c.

{
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    (void) populate_record_worker(fcinfo, "jsonb_populate_record",
                                  false, true, (Node *) &escontext);
 
    return BoolGetDatum(!escontext.error_occurred);
}

References BoolGetDatum(), ErrorSaveContext::error_occurred, and populate_record_worker().

jsonb_populate_recordset()

Datum jsonb_populate_recordset

(

PG_FUNCTION_ARGS

)

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

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    StringInfoData str;
 
    initStringInfo(&str);
    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(), initStringInfo(), JsonbToCStringIndent(), PG_GETARG_JSONB_P, PG_RETURN_TEXT_P, Jsonb::root, str, and VARSIZE().

jsonb_set()

Datum jsonb_set

(

PG_FUNCTION_ARGS

)

Definition at line 4853 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);
    Datum      *path_elems;
    bool       *path_nulls;
    int         path_len;
    JsonbIterator *it;
    JsonbInState st = {0};
 
    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);
 
    setPath(&it, path_elems, path_nulls, path_len, &st,
            0, &newval, create ? JB_PATH_CREATE : JB_PATH_REPLACE);
 
    PG_RETURN_JSONB_P(JsonbValueToJsonb(st.result));
}

References ARR_NDIM, 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, JsonbInState::result, Jsonb::root, and setPath().

Referenced by jsonb_set_lax().

jsonb_set_element()

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

Definition at line 1679 of file jsonfuncs.c.

{
    JsonbInState state = {0};
    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);
 
    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(state.result));
}

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

Referenced by jsonb_subscript_assign().

jsonb_set_lax()

Datum jsonb_set_lax

(

PG_FUNCTION_ARGS

)

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

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    bool        strip_in_arrays = false;
    JsonbIterator *it;
    JsonbInState parseState = {0};
    JsonbValue  v,
                k;
    JsonbIteratorToken type;
    bool        last_was_key = false;
 
    if (PG_NARGS() == 2)
        strip_in_arrays = PG_GETARG_BOOL(1);
 
    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 */
            pushJsonbValue(&parseState, WJB_KEY, &k);
        }
 
        /* if strip_in_arrays is set, also skip null array elements */
        if (strip_in_arrays)
            if (type == WJB_ELEM && v.type == jbvNull)
                continue;
 
        if (type == WJB_VALUE || type == WJB_ELEM)
            pushJsonbValue(&parseState, type, &v);
        else
            pushJsonbValue(&parseState, type, NULL);
    }
 
    PG_RETURN_POINTER(JsonbValueToJsonb(parseState.result));
}

References Assert(), JB_ROOT_IS_SCALAR, jbvNull, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), PG_GETARG_BOOL, PG_GETARG_JSONB_P, PG_NARGS, PG_RETURN_POINTER, pushJsonbValue(), JsonbInState::result, Jsonb::root, 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 2485 of file jsonfuncs.c.

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

References populate_record_worker().

jsonb_to_recordset()

Datum jsonb_to_recordset

(

PG_FUNCTION_ARGS

)

Definition at line 3978 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 1802 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 bool JsValueToJsObject ( JsValue *  jsv, JsObject *  jso, Node *  escontext  )

static

Definition at line 2979 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",
                                    escontext);
        Assert(jso->val.json_hash != NULL || SOFT_ERROR_OCCURRED(escontext));
    }
    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));
            errsave(escontext,
                    (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")));
        }
    }
 
    return !SOFT_ERROR_OCCURRED(escontext);
}

References Assert(), errcode(), errmsg(), errsave, 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, JsValue::len, SOFT_ERROR_OCCURRED, JsValue::str, JsonbValue::type, JsValue::val, JsObject::val, and JsonbValue::val.

Referenced by populate_composite().

makeJsonLexContext()

JsonLexContext * makeJsonLexContext	(	JsonLexContext *	lex,
		text *	json,
		bool	need_escapes
	)

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

okeys_array_start()

static JsonParseErrorType okeys_array_start ( void *  state )

static

Definition at line 809 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 786 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 824 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 5563 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, 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,
		const JsonSemAction *	sem,
		Node *	escontext
	)

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

Referenced by get_json_object_as_hash(), json_in(), jsonb_from_cstring(), and populate_array_json().

populate_array()

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

static

Definition at line 2912 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;
    ctx.escontext = escontext;
 
    if (jsv->is_json)
    {
        /* Return null if an error was found. */
        if (!populate_array_json(&ctx, jsv->val.json.str,
                                 jsv->val.json.len >= 0 ? jsv->val.json.len
                                 : strlen(jsv->val.json.str)))
        {
            *isnull = true;
            return (Datum) 0;
        }
    }
    else
    {
        /* Return null if an error was found. */
        if (!populate_array_dim_jsonb(&ctx, jsv->val.jsonb, 1))
        {
            *isnull = true;
            return (Datum) 0;
        }
        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);
 
    *isnull = false;
    return result;
}

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

Referenced by populate_record_field().

populate_array_array_end()

static JsonParseErrorType populate_array_array_end ( void *  _state )

static

Definition at line 2665 of file jsonfuncs.c.

{
    PopulateArrayState *state = (PopulateArrayState *) _state;
    PopulateArrayContext *ctx = state->ctx;
    int         ndim = state->lex->lex_level;
 
    if (ctx->ndims <= 0)
    {
        if (!populate_array_assign_ndims(ctx, ndim + 1))
            return JSON_SEM_ACTION_FAILED;
    }
 
    if (ndim < ctx->ndims)
    {
        /* Report if an error occurred. */
        if (!populate_array_check_dimension(ctx, ndim))
            return JSON_SEM_ACTION_FAILED;
    }
 
    return JSON_SUCCESS;
}

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

Referenced by populate_array_json().

populate_array_assign_ndims()

static bool populate_array_assign_ndims ( PopulateArrayContext *  ctx, int  ndims  )

static

Definition at line 2557 of file jsonfuncs.c.

{
    int         i;
 
    Assert(ctx->ndims <= 0);
 
    if (ndims <= 0)
    {
        populate_array_report_expected_array(ctx, ndims);
        /* Getting here means the error was reported softly. */
        Assert(SOFT_ERROR_OCCURRED(ctx->escontext));
        return false;
    }
 
    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 */
 
    return true;
}

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

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

populate_array_check_dimension()

static bool populate_array_check_dimension ( PopulateArrayContext *  ctx, int  ndim  )

static

Definition at line 2587 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)
        ereturn(ctx->escontext, false,
                (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]++;
 
    return true;
}

References PopulateArrayContext::dims, ereturn, errcode(), errdetail(), errmsg(), PopulateArrayContext::escontext, and PopulateArrayContext::sizes.

Referenced by populate_array_array_end(), and populate_array_dim_jsonb().

populate_array_dim_jsonb()

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

static

Definition at line 2822 of file jsonfuncs.c.

{
    JsonbContainer *jbc = jbv->val.binary.data;
    JsonbIterator *it;
    JsonbIteratorToken tok;
    JsonbValue  val;
    JsValue     jsv;
 
    check_stack_depth();
 
    /* Even scalars can end up here thanks to ExecEvalJsonCoercion(). */
    if (jbv->type != jbvBinary || !JsonContainerIsArray(jbc) ||
        JsonContainerIsScalar(jbc))
    {
        populate_array_report_expected_array(ctx, ndim - 1);
        /* Getting here means the error was reported softly. */
        Assert(SOFT_ERROR_OCCURRED(ctx->escontext));
        return false;
    }
 
    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)))))
    {
        if (!populate_array_assign_ndims(ctx, ndim))
            return false;
    }
 
    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)
        {
            if (!populate_array_element(ctx, ndim, &jsv))
                return false;
        }
        else
        {
            /* populate child sub-array */
            if (!populate_array_dim_jsonb(ctx, &val, ndim + 1))
                return false;
 
            /* number of dimensions should be already known */
            Assert(ctx->ndims > 0 && ctx->dims);
 
            if (!populate_array_check_dimension(ctx, ndim))
                return false;
        }
 
        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);
 
    return true;
}

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

Referenced by populate_array(), and populate_array_dim_jsonb().

populate_array_element()

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

static

Definition at line 2615 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, ctx->escontext,
                                    false);
    /* Nothing to do on an error. */
    if (SOFT_ERROR_OCCURRED(ctx->escontext))
        return false;
 
    accumArrayResult(ctx->astate, element, element_isnull,
                     ctx->aio->element_type, ctx->acxt);
 
    Assert(ndim > 0);
    ctx->sizes[ndim - 1]++;     /* increment current dimension counter */
 
    return true;
}

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

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 2707 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);
        }
 
        /* Report if an error occurred. */
        if (!populate_array_element(ctx, ndim, &jsv))
            return JSON_SEM_ACTION_FAILED;
    }
 
    return JSON_SUCCESS;
}

References Assert(), JsValue::is_json, JsValue::json, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, JSON_TOKEN_NULL, JsValue::len, PopulateArrayContext::ndims, populate_array_element(), JsValue::str, JsValue::type, 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 2689 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 bool populate_array_json ( PopulateArrayContext *  ctx, const char *  json, int  len  )

static

Definition at line 2786 of file jsonfuncs.c.

{
    PopulateArrayState state;
    JsonSemAction sem;
 
    state.lex = makeJsonLexContextCstringLen(NULL, json, len,
                                             GetDatabaseEncoding(), true);
    state.ctx = ctx;
 
    memset(&sem, 0, sizeof(sem));
    sem.semstate = &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;
 
    if (pg_parse_json_or_errsave(state.lex, &sem, ctx->escontext))
    {
        /* number of dimensions should be already known */
        Assert(ctx->ndims > 0 && ctx->dims);
    }
 
    freeJsonLexContext(state.lex);
 
    return !SOFT_ERROR_OCCURRED(ctx->escontext);
}

References JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, Assert(), PopulateArrayContext::dims, PopulateArrayContext::escontext, freeJsonLexContext(), GetDatabaseEncoding(), len, makeJsonLexContextCstringLen(), PopulateArrayContext::ndims, JsonSemAction::object_start, pg_parse_json_or_errsave(), populate_array_array_end(), populate_array_element_end(), populate_array_element_start(), populate_array_object_start(), populate_array_scalar(), JsonSemAction::scalar, sem, JsonSemAction::semstate, and SOFT_ERROR_OCCURRED.

Referenced by populate_array().

populate_array_object_start()

static JsonParseErrorType populate_array_object_start ( void *  _state )

static

Definition at line 2642 of file jsonfuncs.c.

{
    PopulateArrayState *state = (PopulateArrayState *) _state;
    int         ndim = state->lex->lex_level;
 
    if (state->ctx->ndims <= 0)
    {
        if (!populate_array_assign_ndims(state->ctx, ndim))
            return JSON_SEM_ACTION_FAILED;
    }
    else if (ndim < state->ctx->ndims)
    {
        populate_array_report_expected_array(state->ctx, ndim);
        /* Getting here means the error was reported softly. */
        Assert(SOFT_ERROR_OCCURRED(state->ctx->escontext));
        return JSON_SEM_ACTION_FAILED;
    }
 
    return JSON_SUCCESS;
}

References Assert(), JSON_SEM_ACTION_FAILED, JSON_SUCCESS, populate_array_assign_ndims(), populate_array_report_expected_array(), and SOFT_ERROR_OCCURRED.

Referenced by populate_array_json().

populate_array_report_expected_array()

static void populate_array_report_expected_array ( PopulateArrayContext *  ctx, int  ndim  )

static

Definition at line 2507 of file jsonfuncs.c.

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

References appendStringInfo(), Assert(), PopulateArrayContext::colname, StringInfoData::data, errcode(), errhint(), errmsg(), errsave, PopulateArrayContext::escontext, i, initStringInfo(), PopulateArrayContext::ndims, and PopulateArrayContext::sizes.

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

populate_array_scalar()

static JsonParseErrorType populate_array_scalar ( void *  _state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 2750 of file jsonfuncs.c.

{
    PopulateArrayState *state = (PopulateArrayState *) _state;
    PopulateArrayContext *ctx = state->ctx;
    int         ndim = state->lex->lex_level;
 
    if (ctx->ndims <= 0)
    {
        if (!populate_array_assign_ndims(ctx, ndim))
            return JSON_SEM_ACTION_FAILED;
    }
    else if (ndim < ctx->ndims)
    {
        populate_array_report_expected_array(ctx, ndim);
        /* Getting here means the error was reported softly. */
        Assert(SOFT_ERROR_OCCURRED(ctx->escontext));
        return JSON_SEM_ACTION_FAILED;
    }
 
    if (ndim == ctx->ndims)
    {
        /* remember the scalar element token */
        state->element_scalar = token;
        /* element_type must already be set in populate_array_element_start() */
        Assert(state->element_type == tokentype);
    }
 
    return JSON_SUCCESS;
}

References Assert(), PopulateArrayContext::escontext, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, PopulateArrayContext::ndims, populate_array_assign_ndims(), populate_array_report_expected_array(), SOFT_ERROR_OCCURRED, and token.

Referenced by populate_array_json().

populate_composite()

static Datum populate_composite ( CompositeIOData *  io, Oid  typid, const char *  colname, MemoryContext  mcxt, HeapTupleHeader  defaultval, JsValue *  jsv, bool *  isnull, Node *  escontext  )

static

Definition at line 3055 of file jsonfuncs.c.

{
    Datum       result;
 
    /* acquire/update cached tuple descriptor */
    update_cached_tupdesc(io, mcxt);
 
    if (*isnull)
        result = (Datum) 0;
    else
    {
        HeapTupleHeader tuple;
        JsObject    jso;
 
        /* prepare input value */
        if (!JsValueToJsObject(jsv, &jso, escontext))
        {
            *isnull = true;
            return (Datum) 0;
        }
 
        /* populate resulting record tuple */
        tuple = populate_record(io->tupdesc, &io->record_io,
                                defaultval, mcxt, &jso, escontext);
 
        if (SOFT_ERROR_OCCURRED(escontext))
        {
            *isnull = true;
            return (Datum) 0;
        }
        result = HeapTupleHeaderGetDatum(tuple);
 
        JsObjectFree(&jso);
    }
 
    /*
     * If it's domain over composite, check domain constraints.  (This should
     * probably get refactored so that we can see the TYPECAT value, but for
     * now, we can tell by comparing typid to base_typid.)
     */
    if (typid != io->base_typid && typid != RECORDOID)
    {
        if (!domain_check_safe(result, *isnull, typid, &io->domain_info, mcxt,
                               escontext))
        {
            *isnull = true;
            return (Datum) 0;
        }
    }
 
    return result;
}

References CompositeIOData::base_typid, domain_check_safe(), CompositeIOData::domain_info, HeapTupleHeaderGetDatum(), JsObjectFree, JsValueToJsObject(), populate_record(), CompositeIOData::record_io, SOFT_ERROR_OCCURRED, CompositeIOData::tupdesc, and update_cached_tupdesc().

Referenced by populate_record_field(), and populate_record_worker().

populate_domain()

static Datum populate_domain ( DomainIOData *  io, Oid  typid, const char *  colname, MemoryContext  mcxt, JsValue *  jsv, bool *  isnull, Node *  escontext, bool  omit_quotes  )

static

Definition at line 3214 of file jsonfuncs.c.

{
    Datum       res;
 
    if (*isnull)
        res = (Datum) 0;
    else
    {
        res = populate_record_field(io->base_io,
                                    io->base_typid, io->base_typmod,
                                    colname, mcxt, PointerGetDatum(NULL),
                                    jsv, isnull, escontext, omit_quotes);
        Assert(!*isnull || SOFT_ERROR_OCCURRED(escontext));
    }
 
    if (!domain_check_safe(res, *isnull, typid, &io->domain_info, mcxt,
                           escontext))
    {
        *isnull = true;
        return (Datum) 0;
    }
 
    return res;
}

References Assert(), DomainIOData::base_io, DomainIOData::base_typid, DomainIOData::base_typmod, domain_check_safe(), DomainIOData::domain_info, PointerGetDatum(), populate_record_field(), and SOFT_ERROR_OCCURRED.

Referenced by populate_record_field().

populate_record()

static HeapTupleHeader populate_record ( TupleDesc  tupdesc, RecordIOData **  record_p, HeapTupleHeader  defaultval, MemoryContext  mcxt, JsObject *  obj, Node *  escontext  )

static

Definition at line 3517 of file jsonfuncs.c.

{
    RecordIOData *record = *record_p;
    Datum      *values;
    bool       *nulls;
    HeapTuple   res;
    int         ncolumns = tupdesc->natts;
    int         i;
 
    /*
     * if the input json is empty, we can only skip the rest if we were passed
     * in a non-null record, since otherwise there may be issues with domain
     * nulls.
     */
    if (defaultval && JsObjectIsEmpty(obj))
        return defaultval;
 
    /* (re)allocate metadata cache */
    if (record == NULL ||
        record->ncolumns != ncolumns)
        *record_p = record = allocate_record_info(mcxt, ncolumns);
 
    /* invalidate metadata cache if the record type has changed */
    if (record->record_type != tupdesc->tdtypeid ||
        record->record_typmod != tupdesc->tdtypmod)
    {
        MemSet(record, 0, offsetof(RecordIOData, columns) +
               ncolumns * sizeof(ColumnIOData));
        record->record_type = tupdesc->tdtypeid;
        record->record_typmod = tupdesc->tdtypmod;
        record->ncolumns = ncolumns;
    }
 
    values = (Datum *) palloc(ncolumns * sizeof(Datum));
    nulls = (bool *) palloc(ncolumns * sizeof(bool));
 
    if (defaultval)
    {
        HeapTupleData tuple;
 
        /* Build a temporary HeapTuple control structure */
        tuple.t_len = HeapTupleHeaderGetDatumLength(defaultval);
        ItemPointerSetInvalid(&(tuple.t_self));
        tuple.t_tableOid = InvalidOid;
        tuple.t_data = defaultval;
 
        /* Break down the tuple into fields */
        heap_deform_tuple(&tuple, tupdesc, values, nulls);
    }
    else
    {
        for (i = 0; i < ncolumns; ++i)
        {
            values[i] = (Datum) 0;
            nulls[i] = true;
        }
    }
 
    for (i = 0; i < ncolumns; ++i)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
        char       *colname = NameStr(att->attname);
        JsValue     field = {0};
        bool        found;
 
        /* Ignore dropped columns in datatype */
        if (att->attisdropped)
        {
            nulls[i] = true;
            continue;
        }
 
        found = JsObjectGetField(obj, colname, &field);
 
        /*
         * we can't just skip here if the key wasn't found since we might have
         * a domain to deal with. If we were passed in a non-null record
         * datum, we assume that the existing values are valid (if they're
         * not, then it's not our fault), but if we were passed in a null,
         * then every field which we don't populate needs to be run through
         * the input function just in case it's a domain type.
         */
        if (defaultval && !found)
            continue;
 
        values[i] = populate_record_field(&record->columns[i],
                                          att->atttypid,
                                          att->atttypmod,
                                          colname,
                                          mcxt,
                                          nulls[i] ? (Datum) 0 : values[i],
                                          &field,
                                          &nulls[i],
                                          escontext,
                                          false);
    }
 
    res = heap_form_tuple(tupdesc, values, nulls);
 
    pfree(values);
    pfree(nulls);
 
    return res->t_data;
}

References allocate_record_info(), RecordIOData::columns, heap_deform_tuple(), heap_form_tuple(), HeapTupleHeaderGetDatumLength(), i, InvalidOid, ItemPointerSetInvalid(), JsObjectGetField(), JsObjectIsEmpty, MemSet, NameStr, TupleDescData::natts, RecordIOData::ncolumns, palloc(), pfree(), populate_record_field(), RecordIOData::record_type, RecordIOData::record_typmod, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleDescData::tdtypeid, TupleDescData::tdtypmod, TupleDescAttr(), and values.

Referenced by populate_composite(), and populate_recordset_record().

populate_record_field()

static Datum populate_record_field ( ColumnIOData *  col, Oid  typid, int32  typmod, const char *  colname, MemoryContext  mcxt, Datum  defaultval, JsValue *  jsv, bool *  isnull, Node *  escontext, bool  omit_scalar_quotes  )

static

Definition at line 3403 of file jsonfuncs.c.

{
    TypeCat     typcat;
 
    check_stack_depth();
 
    /*
     * Prepare column metadata cache for the given type.  Force lookup of the
     * scalar_io data so that the json string hack below will work.
     */
    if (col->typid != typid || col->typmod != typmod)
        prepare_column_cache(col, typid, typmod, mcxt, true);
 
    *isnull = JsValueIsNull(jsv);
 
    typcat = col->typcat;
 
    /* try to convert json string to a non-scalar type through input function */
    if (JsValueIsString(jsv) &&
        (typcat == TYPECAT_ARRAY ||
         typcat == TYPECAT_COMPOSITE ||
         typcat == TYPECAT_COMPOSITE_DOMAIN))
        typcat = TYPECAT_SCALAR;
 
    /* we must perform domain checks for NULLs, otherwise exit immediately */
    if (*isnull &&
        typcat != TYPECAT_DOMAIN &&
        typcat != TYPECAT_COMPOSITE_DOMAIN)
        return (Datum) 0;
 
    switch (typcat)
    {
        case TYPECAT_SCALAR:
            return populate_scalar(&col->scalar_io, typid, typmod, jsv,
                                   isnull, escontext, omit_scalar_quotes);
 
        case TYPECAT_ARRAY:
            return populate_array(&col->io.array, colname, mcxt, jsv,
                                  isnull, escontext);
 
        case TYPECAT_COMPOSITE:
        case TYPECAT_COMPOSITE_DOMAIN:
            return populate_composite(&col->io.composite, typid,
                                      colname, mcxt,
                                      DatumGetPointer(defaultval)
                                      ? DatumGetHeapTupleHeader(defaultval)
                                      : NULL,
                                      jsv, isnull,
                                      escontext);
 
        case TYPECAT_DOMAIN:
            return populate_domain(&col->io.domain, typid, colname, mcxt,
                                   jsv, isnull, escontext, omit_scalar_quotes);
 
        default:
            elog(ERROR, "unrecognized type category '%c'", typcat);
            return (Datum) 0;
    }
}

References ColumnIOData::array, check_stack_depth(), ColumnIOData::composite, DatumGetHeapTupleHeader, DatumGetPointer(), ColumnIOData::domain, elog, ERROR, ColumnIOData::io, JsValueIsNull, JsValueIsString, populate_array(), populate_composite(), populate_domain(), populate_scalar(), prepare_column_cache(), ColumnIOData::scalar_io, ColumnIOData::typcat, TYPECAT_ARRAY, TYPECAT_COMPOSITE, TYPECAT_COMPOSITE_DOMAIN, TYPECAT_DOMAIN, TYPECAT_SCALAR, ColumnIOData::typid, and ColumnIOData::typmod.

Referenced by json_populate_type(), populate_array_element(), populate_domain(), and populate_record().

populate_record_worker()

static Datum populate_record_worker ( FunctionCallInfo  fcinfo, const char *  funcname, bool  is_json, bool  have_record_arg, Node *  escontext  )

static

Definition at line 3696 of file jsonfuncs.c.

{
    int         json_arg_num = have_record_arg ? 1 : 0;
    JsValue     jsv = {0};
    HeapTupleHeader rec;
    Datum       rettuple;
    bool        isnull;
    JsonbValue  jbv;
    MemoryContext fnmcxt = fcinfo->flinfo->fn_mcxt;
    PopulateRecordCache *cache = fcinfo->flinfo->fn_extra;
 
    /*
     * If first time through, identify input/result record type.  Note that
     * this stanza looks only at fcinfo context, which can't change during the
     * query; so we may not be able to fully resolve a RECORD input type yet.
     */
    if (!cache)
    {
        fcinfo->flinfo->fn_extra = cache =
            MemoryContextAllocZero(fnmcxt, sizeof(*cache));
        cache->fn_mcxt = fnmcxt;
 
        if (have_record_arg)
            get_record_type_from_argument(fcinfo, funcname, cache);
        else
            get_record_type_from_query(fcinfo, funcname, cache);
    }
 
    /* Collect record arg if we have one */
    if (!have_record_arg)
        rec = NULL;             /* it's json{b}_to_record() */
    else if (!PG_ARGISNULL(0))
    {
        rec = PG_GETARG_HEAPTUPLEHEADER(0);
 
        /*
         * When declared arg type is RECORD, identify actual record type from
         * the tuple itself.
         */
        if (cache->argtype == RECORDOID)
        {
            cache->c.io.composite.base_typid = HeapTupleHeaderGetTypeId(rec);
            cache->c.io.composite.base_typmod = HeapTupleHeaderGetTypMod(rec);
        }
    }
    else
    {
        rec = NULL;
 
        /*
         * When declared arg type is RECORD, identify actual record type from
         * calling query, or fail if we can't.
         */
        if (cache->argtype == RECORDOID)
        {
            get_record_type_from_query(fcinfo, funcname, cache);
            /* This can't change argtype, which is important for next time */
            Assert(cache->argtype == RECORDOID);
        }
    }
 
    /* If no JSON argument, just return the record (if any) unchanged */
    if (PG_ARGISNULL(json_arg_num))
    {
        if (rec)
            PG_RETURN_POINTER(rec);
        else
            PG_RETURN_NULL();
    }
 
    jsv.is_json = is_json;
 
    if (is_json)
    {
        text       *json = PG_GETARG_TEXT_PP(json_arg_num);
 
        jsv.val.json.str = VARDATA_ANY(json);
        jsv.val.json.len = VARSIZE_ANY_EXHDR(json);
        jsv.val.json.type = JSON_TOKEN_INVALID; /* not used in
                                                 * populate_composite() */
    }
    else
    {
        Jsonb      *jb = PG_GETARG_JSONB_P(json_arg_num);
 
        jsv.val.jsonb = &jbv;
 
        /* fill binary jsonb value pointing to jb */
        jbv.type = jbvBinary;
        jbv.val.binary.data = &jb->root;
        jbv.val.binary.len = VARSIZE(jb) - VARHDRSZ;
    }
 
    isnull = false;
    rettuple = populate_composite(&cache->c.io.composite, cache->argtype,
                                  NULL, fnmcxt, rec, &jsv, &isnull,
                                  escontext);
    Assert(!isnull || SOFT_ERROR_OCCURRED(escontext));
 
    PG_RETURN_DATUM(rettuple);
}

References PopulateRecordCache::argtype, Assert(), CompositeIOData::base_typid, CompositeIOData::base_typmod, PopulateRecordCache::c, ColumnIOData::composite, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, PopulateRecordCache::fn_mcxt, FmgrInfo::fn_mcxt, funcname, get_record_type_from_argument(), get_record_type_from_query(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), ColumnIOData::io, JsValue::is_json, jbvBinary, JsValue::json, JSON_TOKEN_INVALID, JsValue::jsonb, JsValue::len, MemoryContextAllocZero(), PG_ARGISNULL, PG_GETARG_HEAPTUPLEHEADER, PG_GETARG_JSONB_P, PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PG_RETURN_NULL, PG_RETURN_POINTER, populate_composite(), Jsonb::root, SOFT_ERROR_OCCURRED, JsValue::str, JsValue::type, JsonbValue::type, JsValue::val, JsonbValue::val, VARDATA_ANY(), VARHDRSZ, VARSIZE(), and VARSIZE_ANY_EXHDR().

Referenced by json_populate_record(), json_to_record(), jsonb_populate_record(), jsonb_populate_record_valid(), and jsonb_to_record().

populate_recordset_array_element_start()

static JsonParseErrorType populate_recordset_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 4265 of file jsonfuncs.c.

{
    PopulateRecordsetState *_state = (PopulateRecordsetState *) state;
 
    if (_state->lex->lex_level == 1 &&
        _state->lex->token_type != JSON_TOKEN_OBJECT_START)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("argument of %s must be an array of objects",
                        _state->function_name)));
 
    return JSON_SUCCESS;
}

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

Referenced by populate_recordset_worker().

populate_recordset_array_start()

static JsonParseErrorType populate_recordset_array_start ( void *  state )

static

Definition at line 4280 of file jsonfuncs.c.

{
    /* nothing to do */
    return JSON_SUCCESS;
}

References JSON_SUCCESS.

Referenced by populate_recordset_worker().

populate_recordset_object_end()

static JsonParseErrorType populate_recordset_object_end ( void *  state )

static

Definition at line 4242 of file jsonfuncs.c.

{
    PopulateRecordsetState *_state = (PopulateRecordsetState *) state;
    JsObject    obj;
 
    /* Nested objects require no special processing */
    if (_state->lex->lex_level > 1)
        return JSON_SUCCESS;
 
    obj.is_json = true;
    obj.val.json_hash = _state->json_hash;
 
    /* Otherwise, construct and return a tuple based on this level-1 object */
    populate_recordset_record(_state, &obj);
 
    /* Done with hash for this object */
    hash_destroy(_state->json_hash);
    _state->json_hash = NULL;
 
    return JSON_SUCCESS;
}

References hash_destroy(), JsObject::is_json, PopulateRecordsetState::json_hash, JsObject::json_hash, JSON_SUCCESS, PopulateRecordsetState::lex, JsonLexContext::lex_level, populate_recordset_record(), and JsObject::val.

Referenced by populate_recordset_worker().

populate_recordset_object_field_end()

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

static

Definition at line 4327 of file jsonfuncs.c.

{
    PopulateRecordsetState *_state = (PopulateRecordsetState *) state;
    JsonHashEntry *hashentry;
    bool        found;
 
    /*
     * Ignore nested fields.
     */
    if (_state->lex->lex_level > 2)
        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->json_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(), HASH_ENTER, hash_search(), PopulateRecordsetState::json_hash, JSON_SUCCESS, JSON_TOKEN_NULL, len, PopulateRecordsetState::lex, JsonLexContext::lex_level, NAMEDATALEN, palloc(), JsonLexContext::prev_token_terminator, PopulateRecordsetState::save_json_start, PopulateRecordsetState::saved_scalar, PopulateRecordsetState::saved_token_type, JsonHashEntry::type, JsonHashEntry::val, and val.

Referenced by populate_recordset_worker().

populate_recordset_object_field_start()

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

static

Definition at line 4304 of file jsonfuncs.c.

{
    PopulateRecordsetState *_state = (PopulateRecordsetState *) state;
 
    if (_state->lex->lex_level > 2)
        return JSON_SUCCESS;
 
    _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)
    {
        _state->save_json_start = _state->lex->token_start;
    }
    else
    {
        _state->save_json_start = NULL;
    }
 
    return JSON_SUCCESS;
}

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

Referenced by populate_recordset_worker().

populate_recordset_object_start()

static JsonParseErrorType populate_recordset_object_start ( void *  state )

static

Definition at line 4212 of file jsonfuncs.c.

{
    PopulateRecordsetState *_state = (PopulateRecordsetState *) state;
    int         lex_level = _state->lex->lex_level;
    HASHCTL     ctl;
 
    /* Reject object at top level: we must have an array at level 0 */
    if (lex_level == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot call %s on an object",
                        _state->function_name)));
 
    /* Nested objects require no special processing */
    if (lex_level > 1)
        return JSON_SUCCESS;
 
    /* Object at level 1: set up a new hash table for this object */
    ctl.keysize = NAMEDATALEN;
    ctl.entrysize = sizeof(JsonHashEntry);
    ctl.hcxt = CurrentMemoryContext;
    _state->json_hash = hash_create("json object hashtable",
                                    100,
                                    &ctl,
                                    HASH_ELEM | HASH_STRINGS | HASH_CONTEXT);
 
    return JSON_SUCCESS;
}

References ctl, CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, PopulateRecordsetState::function_name, HASH_CONTEXT, hash_create(), HASH_ELEM, HASH_STRINGS, PopulateRecordsetState::json_hash, JSON_SUCCESS, PopulateRecordsetState::lex, JsonLexContext::lex_level, and NAMEDATALEN.

Referenced by populate_recordset_worker().

populate_recordset_record()

static void populate_recordset_record ( PopulateRecordsetState *  state, JsObject *  obj  )

static

Definition at line 3999 of file jsonfuncs.c.

{
    PopulateRecordCache *cache = state->cache;
    HeapTupleHeader tuphead;
    HeapTupleData tuple;
 
    /* acquire/update cached tuple descriptor */
    update_cached_tupdesc(&cache->c.io.composite, cache->fn_mcxt);
 
    /* replace record fields from json */
    tuphead = populate_record(cache->c.io.composite.tupdesc,
                              &cache->c.io.composite.record_io,
                              state->rec,
                              cache->fn_mcxt,
                              obj,
                              NULL);
 
    /* if it's domain over composite, check domain constraints */
    if (cache->c.typcat == TYPECAT_COMPOSITE_DOMAIN)
        (void) domain_check_safe(HeapTupleHeaderGetDatum(tuphead), false,
                                 cache->argtype,
                                 &cache->c.io.composite.domain_info,
                                 cache->fn_mcxt,
                                 NULL);
 
    /* ok, save into tuplestore */
    tuple.t_len = HeapTupleHeaderGetDatumLength(tuphead);
    ItemPointerSetInvalid(&(tuple.t_self));
    tuple.t_tableOid = InvalidOid;
    tuple.t_data = tuphead;
 
    tuplestore_puttuple(state->tuple_store, &tuple);
}

References PopulateRecordCache::argtype, PopulateRecordCache::c, ColumnIOData::composite, domain_check_safe(), CompositeIOData::domain_info, PopulateRecordCache::fn_mcxt, HeapTupleHeaderGetDatum(), HeapTupleHeaderGetDatumLength(), InvalidOid, ColumnIOData::io, ItemPointerSetInvalid(), populate_record(), CompositeIOData::record_io, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, CompositeIOData::tupdesc, tuplestore_puttuple(), ColumnIOData::typcat, TYPECAT_COMPOSITE_DOMAIN, and update_cached_tupdesc().

Referenced by populate_recordset_object_end(), and populate_recordset_worker().

populate_recordset_scalar()

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

static

Definition at line 4287 of file jsonfuncs.c.

{
    PopulateRecordsetState *_state = (PopulateRecordsetState *) 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 == 2)
        _state->saved_scalar = token;
 
    return JSON_SUCCESS;
}

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

Referenced by populate_recordset_worker().

populate_recordset_worker()

static Datum populate_recordset_worker ( FunctionCallInfo  fcinfo, const char *  funcname, bool  is_json, bool  have_record_arg  )

static

Definition at line 4038 of file jsonfuncs.c.

{
    int         json_arg_num = have_record_arg ? 1 : 0;
    ReturnSetInfo *rsi;
    MemoryContext old_cxt;
    HeapTupleHeader rec;
    PopulateRecordCache *cache = fcinfo->flinfo->fn_extra;
    PopulateRecordsetState *state;
 
    rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 
    if (!rsi || !IsA(rsi, ReturnSetInfo))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("set-valued function called in context that cannot accept a set")));
 
    if (!(rsi->allowedModes & SFRM_Materialize))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("materialize mode required, but it is not allowed in this context")));
 
    rsi->returnMode = SFRM_Materialize;
 
    /*
     * If first time through, identify input/result record type.  Note that
     * this stanza looks only at fcinfo context, which can't change during the
     * query; so we may not be able to fully resolve a RECORD input type yet.
     */
    if (!cache)
    {
        fcinfo->flinfo->fn_extra = cache =
            MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt, sizeof(*cache));
        cache->fn_mcxt = fcinfo->flinfo->fn_mcxt;
 
        if (have_record_arg)
            get_record_type_from_argument(fcinfo, funcname, cache);
        else
            get_record_type_from_query(fcinfo, funcname, cache);
    }
 
    /* Collect record arg if we have one */
    if (!have_record_arg)
        rec = NULL;             /* it's json{b}_to_recordset() */
    else if (!PG_ARGISNULL(0))
    {
        rec = PG_GETARG_HEAPTUPLEHEADER(0);
 
        /*
         * When declared arg type is RECORD, identify actual record type from
         * the tuple itself.
         */
        if (cache->argtype == RECORDOID)
        {
            cache->c.io.composite.base_typid = HeapTupleHeaderGetTypeId(rec);
            cache->c.io.composite.base_typmod = HeapTupleHeaderGetTypMod(rec);
        }
    }
    else
    {
        rec = NULL;
 
        /*
         * When declared arg type is RECORD, identify actual record type from
         * calling query, or fail if we can't.
         */
        if (cache->argtype == RECORDOID)
        {
            get_record_type_from_query(fcinfo, funcname, cache);
            /* This can't change argtype, which is important for next time */
            Assert(cache->argtype == RECORDOID);
        }
    }
 
    /* if the json is null send back an empty set */
    if (PG_ARGISNULL(json_arg_num))
        PG_RETURN_NULL();
 
    /*
     * Forcibly update the cached tupdesc, to ensure we have the right tupdesc
     * to return even if the JSON contains no rows.
     */
    update_cached_tupdesc(&cache->c.io.composite, cache->fn_mcxt);
 
    state = palloc0(sizeof(PopulateRecordsetState));
 
    /* make tuplestore in a sufficiently long-lived memory context */
    old_cxt = MemoryContextSwitchTo(rsi->econtext->ecxt_per_query_memory);
    state->tuple_store = tuplestore_begin_heap(rsi->allowedModes &
                                               SFRM_Materialize_Random,
                                               false, work_mem);
    MemoryContextSwitchTo(old_cxt);
 
    state->function_name = funcname;
    state->cache = cache;
    state->rec = rec;
 
    if (is_json)
    {
        text       *json = PG_GETARG_TEXT_PP(json_arg_num);
        JsonLexContext lex;
        JsonSemAction *sem;
 
        sem = palloc0(sizeof(JsonSemAction));
 
        makeJsonLexContext(&lex, json, true);
 
        sem->semstate = state;
        sem->array_start = populate_recordset_array_start;
        sem->array_element_start = populate_recordset_array_element_start;
        sem->scalar = populate_recordset_scalar;
        sem->object_field_start = populate_recordset_object_field_start;
        sem->object_field_end = populate_recordset_object_field_end;
        sem->object_start = populate_recordset_object_start;
        sem->object_end = populate_recordset_object_end;
 
        state->lex = &lex;
 
        pg_parse_json_or_ereport(&lex, sem);
 
        freeJsonLexContext(&lex);
        state->lex = NULL;
    }
    else
    {
        Jsonb      *jb = PG_GETARG_JSONB_P(json_arg_num);
        JsonbIterator *it;
        JsonbValue  v;
        bool        skipNested = false;
        JsonbIteratorToken r;
 
        if (JB_ROOT_IS_SCALAR(jb) || !JB_ROOT_IS_ARRAY(jb))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("cannot call %s on a non-array",
                            funcname)));
 
        it = JsonbIteratorInit(&jb->root);
 
        while ((r = JsonbIteratorNext(&it, &v, skipNested)) != WJB_DONE)
        {
            skipNested = true;
 
            if (r == WJB_ELEM)
            {
                JsObject    obj;
 
                if (v.type != jbvBinary ||
                    !JsonContainerIsObject(v.val.binary.data))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("argument of %s must be an array of objects",
                                    funcname)));
 
                obj.is_json = false;
                obj.val.jsonb_cont = v.val.binary.data;
 
                populate_recordset_record(state, &obj);
            }
        }
    }
 
    /*
     * Note: we must copy the cached tupdesc because the executor will free
     * the passed-back setDesc, but we want to hang onto the cache in case
     * we're called again in the same query.
     */
    rsi->setResult = state->tuple_store;
    rsi->setDesc = CreateTupleDescCopy(cache->c.io.composite.tupdesc);
 
    PG_RETURN_NULL();
}

References ReturnSetInfo::allowedModes, PopulateRecordCache::argtype, JsonSemAction::array_element_start, JsonSemAction::array_start, Assert(), CompositeIOData::base_typid, CompositeIOData::base_typmod, PopulateRecordCache::c, ColumnIOData::composite, CreateTupleDescCopy(), ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, PopulateRecordCache::fn_mcxt, FmgrInfo::fn_mcxt, freeJsonLexContext(), funcname, get_record_type_from_argument(), get_record_type_from_query(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), if(), ColumnIOData::io, JsObject::is_json, IsA, JB_ROOT_IS_ARRAY, JB_ROOT_IS_SCALAR, jbvBinary, JsObject::jsonb_cont, JsonbIteratorInit(), JsonbIteratorNext(), JsonContainerIsObject, makeJsonLexContext(), MemoryContextAllocZero(), MemoryContextSwitchTo(), JsonSemAction::object_end, JsonSemAction::object_field_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc0(), PG_ARGISNULL, PG_GETARG_HEAPTUPLEHEADER, PG_GETARG_JSONB_P, PG_GETARG_TEXT_PP, pg_parse_json_or_ereport, PG_RETURN_NULL, populate_recordset_array_element_start(), populate_recordset_array_start(), populate_recordset_object_end(), populate_recordset_object_field_end(), populate_recordset_object_field_start(), populate_recordset_object_start(), populate_recordset_record(), populate_recordset_scalar(), FunctionCallInfoBaseData::resultinfo, ReturnSetInfo::returnMode, Jsonb::root, JsonSemAction::scalar, sem, JsonSemAction::semstate, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Random, CompositeIOData::tupdesc, tuplestore_begin_heap(), JsonbValue::type, update_cached_tupdesc(), JsObject::val, JsonbValue::val, WJB_DONE, WJB_ELEM, and work_mem.

Referenced by json_populate_recordset(), json_to_recordset(), jsonb_populate_recordset(), and jsonb_to_recordset().

populate_scalar()

static Datum populate_scalar ( ScalarIOData *  io, Oid  typid, int32  typmod, JsValue *  jsv, bool *  isnull, Node *  escontext, bool  omit_quotes  )

static

Definition at line 3122 of file jsonfuncs.c.

{
    Datum       res;
    char       *str = NULL;
    const char *json = NULL;
 
    if (jsv->is_json)
    {
        int         len = jsv->val.json.len;
 
        json = jsv->val.json.str;
        Assert(json);
 
        /* If converting to json/jsonb, make string into valid JSON literal */
        if ((typid == JSONOID || typid == JSONBOID) &&
            jsv->val.json.type == JSON_TOKEN_STRING)
        {
            StringInfoData buf;
 
            initStringInfo(&buf);
            if (len >= 0)
                escape_json_with_len(&buf, json, len);
            else
                escape_json(&buf, json);
            str = buf.data;
        }
        else if (len >= 0)
        {
            /* create a NUL-terminated version */
            str = palloc(len + 1);
            memcpy(str, json, len);
            str[len] = '\0';
        }
        else
        {
            /* string is already NUL-terminated */
            str = unconstify(char *, json);
        }
    }
    else
    {
        JsonbValue *jbv = jsv->val.jsonb;
 
        if (jbv->type == jbvString && omit_quotes)
            str = pnstrdup(jbv->val.string.val, jbv->val.string.len);
        else if (typid == JSONBOID)
        {
            Jsonb      *jsonb = JsonbValueToJsonb(jbv); /* directly use jsonb */
 
            return JsonbPGetDatum(jsonb);
        }
        /* convert jsonb to string for typio call */
        else if (typid == JSONOID && jbv->type != jbvBinary)
        {
            /*
             * Convert scalar jsonb (non-scalars are passed here as jbvBinary)
             * to json string, preserving quotes around top-level strings.
             */
            Jsonb      *jsonb = JsonbValueToJsonb(jbv);
 
            str = JsonbToCString(NULL, &jsonb->root, VARSIZE(jsonb));
        }
        else if (jbv->type == jbvString)    /* quotes are stripped */
            str = pnstrdup(jbv->val.string.val, jbv->val.string.len);
        else if (jbv->type == jbvBool)
            str = pstrdup(jbv->val.boolean ? "true" : "false");
        else if (jbv->type == jbvNumeric)
            str = DatumGetCString(DirectFunctionCall1(numeric_out,
                                                      PointerGetDatum(jbv->val.numeric)));
        else if (jbv->type == jbvBinary)
            str = JsonbToCString(NULL, jbv->val.binary.data,
                                 jbv->val.binary.len);
        else
            elog(ERROR, "unrecognized jsonb type: %d", (int) jbv->type);
    }
 
    if (!InputFunctionCallSafe(&io->typiofunc, str, io->typioparam, typmod,
                               escontext, &res))
    {
        res = (Datum) 0;
        *isnull = true;
    }
 
    /* free temporary buffer */
    if (str != json)
        pfree(str);
 
    return res;
}

References Assert(), buf, DatumGetCString(), DirectFunctionCall1, elog, ERROR, escape_json(), escape_json_with_len(), initStringInfo(), InputFunctionCallSafe(), JsValue::is_json, jbvBinary, jbvBool, jbvNumeric, jbvString, JsValue::json, JSON_TOKEN_STRING, JsValue::jsonb, JsonbPGetDatum(), JsonbToCString(), JsonbValueToJsonb(), JsValue::len, len, numeric_out(), palloc(), pfree(), pnstrdup(), PointerGetDatum(), pstrdup(), Jsonb::root, JsValue::str, str, JsValue::type, JsonbValue::type, ScalarIOData::typiofunc, ScalarIOData::typioparam, unconstify, JsValue::val, JsonbValue::val, and VARSIZE().

Referenced by populate_record_field().

prepare_column_cache()

static void prepare_column_cache ( ColumnIOData *  column, Oid  typid, int32  typmod, MemoryContext  mcxt, bool  need_scalar  )

static

Definition at line 3248 of file jsonfuncs.c.

{
    HeapTuple   tup;
    Form_pg_type type;
 
    column->typid = typid;
    column->typmod = typmod;
 
    tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for type %u", typid);
 
    type = (Form_pg_type) GETSTRUCT(tup);
 
    if (type->typtype == TYPTYPE_DOMAIN)
    {
        /*
         * We can move directly to the bottom base type; domain_check() will
         * take care of checking all constraints for a stack of domains.
         */
        Oid         base_typid;
        int32       base_typmod = typmod;
 
        base_typid = getBaseTypeAndTypmod(typid, &base_typmod);
        if (get_typtype(base_typid) == TYPTYPE_COMPOSITE)
        {
            /* domain over composite has its own code path */
            column->typcat = TYPECAT_COMPOSITE_DOMAIN;
            column->io.composite.record_io = NULL;
            column->io.composite.tupdesc = NULL;
            column->io.composite.base_typid = base_typid;
            column->io.composite.base_typmod = base_typmod;
            column->io.composite.domain_info = NULL;
        }
        else
        {
            /* domain over anything else */
            column->typcat = TYPECAT_DOMAIN;
            column->io.domain.base_typid = base_typid;
            column->io.domain.base_typmod = base_typmod;
            column->io.domain.base_io =
                MemoryContextAllocZero(mcxt, sizeof(ColumnIOData));
            column->io.domain.domain_info = NULL;
        }
    }
    else if (type->typtype == TYPTYPE_COMPOSITE || typid == RECORDOID)
    {
        column->typcat = TYPECAT_COMPOSITE;
        column->io.composite.record_io = NULL;
        column->io.composite.tupdesc = NULL;
        column->io.composite.base_typid = typid;
        column->io.composite.base_typmod = typmod;
        column->io.composite.domain_info = NULL;
    }
    else if (IsTrueArrayType(type))
    {
        column->typcat = TYPECAT_ARRAY;
        column->io.array.element_info = MemoryContextAllocZero(mcxt,
                                                               sizeof(ColumnIOData));
        column->io.array.element_type = type->typelem;
        /* array element typemod stored in attribute's typmod */
        column->io.array.element_typmod = typmod;
    }
    else
    {
        column->typcat = TYPECAT_SCALAR;
        need_scalar = true;
    }
 
    /* caller can force us to look up scalar_io info even for non-scalars */
    if (need_scalar)
    {
        Oid         typioproc;
 
        getTypeInputInfo(typid, &typioproc, &column->scalar_io.typioparam);
        fmgr_info_cxt(typioproc, &column->scalar_io.typiofunc, mcxt);
    }
 
    ReleaseSysCache(tup);
}

References ColumnIOData::array, DomainIOData::base_io, CompositeIOData::base_typid, DomainIOData::base_typid, CompositeIOData::base_typmod, DomainIOData::base_typmod, ColumnIOData::composite, ColumnIOData::domain, CompositeIOData::domain_info, DomainIOData::domain_info, ArrayIOData::element_info, ArrayIOData::element_type, ArrayIOData::element_typmod, elog, ERROR, fmgr_info_cxt(), get_typtype(), getBaseTypeAndTypmod(), GETSTRUCT(), getTypeInputInfo(), HeapTupleIsValid, ColumnIOData::io, MemoryContextAllocZero(), ObjectIdGetDatum(), CompositeIOData::record_io, ReleaseSysCache(), ColumnIOData::scalar_io, SearchSysCache1(), CompositeIOData::tupdesc, ColumnIOData::typcat, type, TYPECAT_ARRAY, TYPECAT_COMPOSITE, TYPECAT_COMPOSITE_DOMAIN, TYPECAT_DOMAIN, TYPECAT_SCALAR, ColumnIOData::typid, ScalarIOData::typiofunc, ScalarIOData::typioparam, and ColumnIOData::typmod.

Referenced by get_record_type_from_argument(), and populate_record_field().

push_null_elements()

static void push_null_elements ( JsonbInState *  ps, int  num  )

static

Definition at line 1701 of file jsonfuncs.c.

{
    JsonbValue  null;
 
    null.type = jbvNull;
 
    while (num-- > 0)
        pushJsonbValue(ps, WJB_ELEM, &null);
}

References jbvNull, ps, pushJsonbValue(), JsonbValue::type, and WJB_ELEM.

Referenced by push_path(), and setPathArray().

push_path()

static void push_path ( JsonbInState *  st, int  level, const Datum *  path_elems, const bool *  path_nulls, int  path_len, JsonbValue *  newval  )

static

Definition at line 1720 of file jsonfuncs.c.

{
    /*
     * tpath contains expected type of an empty jsonb created at each level
     * higher or equal to the current one, either jbvObject or jbvArray. Since
     * it contains only information about path slice from level to the end,
     * the access index must be normalized by level.
     */
    enum jbvType *tpath = palloc0((path_len - level) * sizeof(enum jbvType));
    JsonbValue  newkey;
 
    /*
     * Create first part of the chain with beginning tokens. For the current
     * level WJB_BEGIN_OBJECT/WJB_BEGIN_ARRAY was already created, so start
     * with the next one.
     */
    for (int i = level + 1; i < path_len; i++)
    {
        char       *c,
                   *badp;
        int         lindex;
 
        if (path_nulls[i])
            break;
 
        /*
         * Try to convert to an integer to find out the expected type, object
         * or array.
         */
        c = TextDatumGetCString(path_elems[i]);
        errno = 0;
        lindex = strtoint(c, &badp, 10);
        if (badp == c || *badp != '\0' || errno != 0)
        {
            /* text, an object is expected */
            newkey.type = jbvString;
            newkey.val.string.val = c;
            newkey.val.string.len = strlen(c);
 
            pushJsonbValue(st, WJB_BEGIN_OBJECT, NULL);
            pushJsonbValue(st, WJB_KEY, &newkey);
 
            tpath[i - level] = jbvObject;
        }
        else
        {
            /* integer, an array is expected */
            pushJsonbValue(st, WJB_BEGIN_ARRAY, NULL);
 
            push_null_elements(st, lindex);
 
            tpath[i - level] = jbvArray;
        }
    }
 
    /* Insert an actual value for either an object or array */
    if (tpath[(path_len - level) - 1] == jbvArray)
        pushJsonbValue(st, WJB_ELEM, newval);
    else
        pushJsonbValue(st, WJB_VALUE, newval);
 
    /*
     * Close everything up to the last but one level. The last one will be
     * closed outside of this function.
     */
    for (int i = path_len - 1; i > level; i--)
    {
        if (path_nulls[i])
            break;
 
        if (tpath[i - level] == jbvObject)
            pushJsonbValue(st, WJB_END_OBJECT, NULL);
        else
            pushJsonbValue(st, WJB_END_ARRAY, NULL);
    }
}

References i, jbvArray, jbvObject, jbvString, newval, palloc0(), push_null_elements(), pushJsonbValue(), strtoint(), TextDatumGetCString, JsonbValue::type, JsonbValue::val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by setPathArray(), and setPathObject().

report_json_context()

static int report_json_context ( JsonLexContext *  lex )

static

Definition at line 677 of file jsonfuncs.c.

{
    const char *context_start;
    const char *context_end;
    const char *line_start;
    char       *ctxt;
    int         ctxtlen;
    const char *prefix;
    const char *suffix;
 
    /* Choose boundaries for the part of the input we will display */
    line_start = lex->line_start;
    context_start = line_start;
    context_end = lex->token_terminator;
    Assert(context_end >= context_start);
 
    /* Advance until we are close enough to context_end */
    while (context_end - context_start >= 50)
    {
        /* Advance to next multibyte character */
        if (IS_HIGHBIT_SET(*context_start))
            context_start += pg_mblen(context_start);
        else
            context_start++;
    }
 
    /*
     * We add "..." to indicate that the excerpt doesn't start at the
     * beginning of the line ... but if we're within 3 characters of the
     * beginning of the line, we might as well just show the whole line.
     */
    if (context_start - line_start <= 3)
        context_start = line_start;
 
    /* Get a null-terminated copy of the data to present */
    ctxtlen = context_end - context_start;
    ctxt = palloc(ctxtlen + 1);
    memcpy(ctxt, context_start, ctxtlen);
    ctxt[ctxtlen] = '\0';
 
    /*
     * Show the context, prefixing "..." if not starting at start of line, and
     * suffixing "..." if not ending at end of line.
     */
    prefix = (context_start > line_start) ? "..." : "";
    suffix = (lex->token_type != JSON_TOKEN_END &&
              context_end - lex->input < lex->input_length &&
              *context_end != '\n' && *context_end != '\r') ? "..." : "";
 
    return errcontext("JSON data, line %d: %s%s%s",
                      lex->line_number, prefix, ctxt, suffix);
}

References Assert(), errcontext, JsonLexContext::input, JsonLexContext::input_length, IS_HIGHBIT_SET, JSON_TOKEN_END, JsonLexContext::line_number, JsonLexContext::line_start, palloc(), pg_mblen(), JsonLexContext::token_terminator, and JsonLexContext::token_type.

Referenced by json_errsave_error().

setPath()

static void setPath ( JsonbIterator **  it, const Datum *  path_elems, const bool *  path_nulls, int  path_len, JsonbInState *  st, int  level, JsonbValue *  newval, int  op_type  )

static

Definition at line 5177 of file jsonfuncs.c.

{
    JsonbValue  v;
    JsonbIteratorToken r;
 
    check_stack_depth();
 
    if (path_nulls[level])
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("path element at position %d is null",
                        level + 1)));
 
    r = JsonbIteratorNext(it, &v, false);
 
    switch (r)
    {
        case WJB_BEGIN_ARRAY:
 
            /*
             * If instructed complain about attempts to replace within a raw
             * scalar value. This happens even when current level is equal to
             * path_len, because the last path key should also correspond to
             * an object or an array, not raw scalar.
             */
            if ((op_type & JB_PATH_FILL_GAPS) && (level <= path_len - 1) &&
                v.val.array.rawScalar)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("cannot replace existing key"),
                         errdetail("The path assumes key is a composite object, "
                                   "but it is a scalar value.")));
 
            pushJsonbValue(st, r, NULL);
            setPathArray(it, path_elems, path_nulls, path_len, st, level,
                         newval, v.val.array.nElems, op_type);
            r = JsonbIteratorNext(it, &v, false);
            Assert(r == WJB_END_ARRAY);
            pushJsonbValue(st, r, NULL);
            break;
        case WJB_BEGIN_OBJECT:
            pushJsonbValue(st, r, NULL);
            setPathObject(it, path_elems, path_nulls, path_len, st, level,
                          newval, v.val.object.nPairs, op_type);
            r = JsonbIteratorNext(it, &v, true);
            Assert(r == WJB_END_OBJECT);
            pushJsonbValue(st, r, NULL);
            break;
        case WJB_ELEM:
        case WJB_VALUE:
 
            /*
             * If instructed complain about attempts to replace within a
             * scalar value. This happens even when current level is equal to
             * path_len, because the last path key should also correspond to
             * an object or an array, not an element or value.
             */
            if ((op_type & JB_PATH_FILL_GAPS) && (level <= path_len - 1))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("cannot replace existing key"),
                         errdetail("The path assumes key is a composite object, "
                                   "but it is a scalar value.")));
 
            pushJsonbValue(st, r, &v);
            break;
        default:
            elog(ERROR, "unrecognized iterator result: %d", (int) r);
            break;
    }
}

References Assert(), check_stack_depth(), elog, ereport, errcode(), errdetail(), errmsg(), ERROR, JB_PATH_FILL_GAPS, JsonbIteratorNext(), newval, pushJsonbValue(), setPathArray(), setPathObject(), JsonbValue::val, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, and WJB_VALUE.

Referenced by jsonb_delete_path(), jsonb_insert(), jsonb_set(), jsonb_set_element(), setPathArray(), and setPathObject().

setPathArray()

static void setPathArray ( JsonbIterator **  it, const Datum *  path_elems, const bool *  path_nulls, int  path_len, JsonbInState *  st, int  level, JsonbValue *  newval, uint32  nelems, int  op_type  )

static

Definition at line 5393 of file jsonfuncs.c.

{
    JsonbValue  v;
    int         idx,
                i;
    bool        done = false;
 
    /* pick correct index */
    if (level < path_len && !path_nulls[level])
    {
        char       *c = TextDatumGetCString(path_elems[level]);
        char       *badp;
 
        errno = 0;
        idx = strtoint(c, &badp, 10);
        if (badp == c || *badp != '\0' || errno != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("path element at position %d is not an integer: \"%s\"",
                            level + 1, c)));
    }
    else
        idx = nelems;
 
    if (idx < 0)
    {
        if (pg_abs_s32(idx) > nelems)
        {
            /*
             * If asked to keep elements position consistent, it's not allowed
             * to prepend the array.
             */
            if (op_type & JB_PATH_CONSISTENT_POSITION)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("path element at position %d is out of range: %d",
                                level + 1, idx)));
            else
                idx = PG_INT32_MIN;
        }
        else
            idx = nelems + idx;
    }
 
    /*
     * Filling the gaps means there are no limits on the positive index are
     * imposed, we can set any element. Otherwise limit the index by nelems.
     */
    if (!(op_type & JB_PATH_FILL_GAPS))
    {
        if (idx > 0 && idx > nelems)
            idx = nelems;
    }
 
    /*
     * if we're creating, and idx == INT_MIN, we prepend the new value to the
     * array also if the array is empty - in which case we don't really care
     * what the idx value is
     */
    if ((idx == INT_MIN || nelems == 0) && (level == path_len - 1) &&
        (op_type & JB_PATH_CREATE_OR_INSERT))
    {
        Assert(newval != NULL);
 
        if (op_type & JB_PATH_FILL_GAPS && nelems == 0 && idx > 0)
            push_null_elements(st, idx);
 
        pushJsonbValue(st, WJB_ELEM, newval);
 
        done = true;
    }
 
    /* iterate over the array elements */
    for (i = 0; i < nelems; i++)
    {
        JsonbIteratorToken r;
 
        if (i == idx && level < path_len)
        {
            done = true;
 
            if (level == path_len - 1)
            {
                r = JsonbIteratorNext(it, &v, true);    /* skip */
 
                if (op_type & (JB_PATH_INSERT_BEFORE | JB_PATH_CREATE))
                    pushJsonbValue(st, WJB_ELEM, newval);
 
                /*
                 * We should keep current value only in case of
                 * JB_PATH_INSERT_BEFORE or JB_PATH_INSERT_AFTER because
                 * otherwise it should be deleted or replaced
                 */
                if (op_type & (JB_PATH_INSERT_AFTER | JB_PATH_INSERT_BEFORE))
                    pushJsonbValue(st, r, &v);
 
                if (op_type & (JB_PATH_INSERT_AFTER | JB_PATH_REPLACE))
                    pushJsonbValue(st, WJB_ELEM, newval);
            }
            else
                setPath(it, path_elems, path_nulls, path_len,
                        st, level + 1, newval, op_type);
        }
        else
        {
            r = JsonbIteratorNext(it, &v, false);
 
            pushJsonbValue(st, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
 
            if (r == WJB_BEGIN_ARRAY || r == WJB_BEGIN_OBJECT)
            {
                int         walking_level = 1;
 
                while (walking_level != 0)
                {
                    r = JsonbIteratorNext(it, &v, false);
 
                    if (r == WJB_BEGIN_ARRAY || r == WJB_BEGIN_OBJECT)
                        ++walking_level;
                    if (r == WJB_END_ARRAY || r == WJB_END_OBJECT)
                        --walking_level;
 
                    pushJsonbValue(st, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
                }
            }
        }
    }
 
    if ((op_type & JB_PATH_CREATE_OR_INSERT) && !done && level == path_len - 1)
    {
        /*
         * If asked to fill the gaps, idx could be bigger than nelems, so
         * prepend the new element with nulls if that's the case.
         */
        if (op_type & JB_PATH_FILL_GAPS && idx > nelems)
            push_null_elements(st, idx - nelems);
 
        pushJsonbValue(st, WJB_ELEM, newval);
        done = true;
    }
 
    /*--
     * If we got here there are only few possibilities:
     * - no target path was found, and an open array with some keys/values was
     *   pushed into the state
     * - an array is empty, only WJB_BEGIN_ARRAY is pushed
     *
     * In both cases if instructed to create the path when not present,
     * generate the whole chain of empty objects and insert the new value
     * there.
     */
    if (!done && (op_type & JB_PATH_FILL_GAPS) && (level < path_len - 1))
    {
        if (idx > 0)
            push_null_elements(st, idx - nelems);
 
        push_path(st, level, path_elems, path_nulls, path_len, newval);
 
        /* Result is closed with WJB_END_OBJECT outside of this function */
    }
}

References Assert(), ereport, errcode(), errmsg(), ERROR, i, idx(), JB_PATH_CONSISTENT_POSITION, JB_PATH_CREATE, JB_PATH_CREATE_OR_INSERT, JB_PATH_FILL_GAPS, JB_PATH_INSERT_AFTER, JB_PATH_INSERT_BEFORE, JB_PATH_REPLACE, JsonbIteratorNext(), newval, pg_abs_s32(), PG_INT32_MIN, push_null_elements(), push_path(), pushJsonbValue(), setPath(), strtoint(), TextDatumGetCString, WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_ELEM, WJB_END_ARRAY, and WJB_END_OBJECT.

Referenced by setPath().

setPathObject()

static void setPathObject ( JsonbIterator **  it, const Datum *  path_elems, const bool *  path_nulls, int  path_len, JsonbInState *  st, int  level, JsonbValue *  newval, uint32  npairs, int  op_type  )

static

Definition at line 5255 of file jsonfuncs.c.

{
    text       *pathelem = NULL;
    int         i;
    JsonbValue  k,
                v;
    bool        done = false;
 
    if (level >= path_len || path_nulls[level])
        done = true;
    else
    {
        /* The path Datum could be toasted, in which case we must detoast it */
        pathelem = DatumGetTextPP(path_elems[level]);
    }
 
    /* empty object is a special case for create */
    if ((npairs == 0) && (op_type & JB_PATH_CREATE_OR_INSERT) &&
        (level == path_len - 1))
    {
        JsonbValue  newkey;
 
        newkey.type = jbvString;
        newkey.val.string.val = VARDATA_ANY(pathelem);
        newkey.val.string.len = VARSIZE_ANY_EXHDR(pathelem);
 
        pushJsonbValue(st, WJB_KEY, &newkey);
        pushJsonbValue(st, WJB_VALUE, newval);
    }
 
    for (i = 0; i < npairs; i++)
    {
        JsonbIteratorToken r = JsonbIteratorNext(it, &k, true);
 
        Assert(r == WJB_KEY);
 
        if (!done &&
            k.val.string.len == VARSIZE_ANY_EXHDR(pathelem) &&
            memcmp(k.val.string.val, VARDATA_ANY(pathelem),
                   k.val.string.len) == 0)
        {
            done = true;
 
            if (level == path_len - 1)
            {
                /*
                 * called from jsonb_insert(), it forbids redefining an
                 * existing value
                 */
                if (op_type & (JB_PATH_INSERT_BEFORE | JB_PATH_INSERT_AFTER))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("cannot replace existing key"),
                             errhint("Try using the function jsonb_set "
                                     "to replace key value.")));
 
                r = JsonbIteratorNext(it, &v, true);    /* skip value */
                if (!(op_type & JB_PATH_DELETE))
                {
                    pushJsonbValue(st, WJB_KEY, &k);
                    pushJsonbValue(st, WJB_VALUE, newval);
                }
            }
            else
            {
                pushJsonbValue(st, r, &k);
                setPath(it, path_elems, path_nulls, path_len,
                        st, level + 1, newval, op_type);
            }
        }
        else
        {
            if ((op_type & JB_PATH_CREATE_OR_INSERT) && !done &&
                level == path_len - 1 && i == npairs - 1)
            {
                JsonbValue  newkey;
 
                newkey.type = jbvString;
                newkey.val.string.val = VARDATA_ANY(pathelem);
                newkey.val.string.len = VARSIZE_ANY_EXHDR(pathelem);
 
                pushJsonbValue(st, WJB_KEY, &newkey);
                pushJsonbValue(st, WJB_VALUE, newval);
            }
 
            pushJsonbValue(st, r, &k);
            r = JsonbIteratorNext(it, &v, false);
            pushJsonbValue(st, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
            if (r == WJB_BEGIN_ARRAY || r == WJB_BEGIN_OBJECT)
            {
                int         walking_level = 1;
 
                while (walking_level != 0)
                {
                    r = JsonbIteratorNext(it, &v, false);
 
                    if (r == WJB_BEGIN_ARRAY || r == WJB_BEGIN_OBJECT)
                        ++walking_level;
                    if (r == WJB_END_ARRAY || r == WJB_END_OBJECT)
                        --walking_level;
 
                    pushJsonbValue(st, r, r < WJB_BEGIN_ARRAY ? &v : NULL);
                }
            }
        }
    }
 
    /*--
     * If we got here there are only few possibilities:
     * - no target path was found, and an open object with some keys/values was
     *   pushed into the state
     * - an object is empty, only WJB_BEGIN_OBJECT is pushed
     *
     * In both cases if instructed to create the path when not present,
     * generate the whole chain of empty objects and insert the new value
     * there.
     */
    if (!done && (op_type & JB_PATH_FILL_GAPS) && (level < path_len - 1))
    {
        JsonbValue  newkey;
 
        newkey.type = jbvString;
        newkey.val.string.val = VARDATA_ANY(pathelem);
        newkey.val.string.len = VARSIZE_ANY_EXHDR(pathelem);
 
        pushJsonbValue(st, WJB_KEY, &newkey);
        push_path(st, level, path_elems, path_nulls, path_len, newval);
 
        /* Result is closed with WJB_END_OBJECT outside of this function */
    }
}

References Assert(), DatumGetTextPP, ereport, errcode(), errhint(), errmsg(), ERROR, i, JB_PATH_CREATE_OR_INSERT, JB_PATH_DELETE, JB_PATH_FILL_GAPS, JB_PATH_INSERT_AFTER, JB_PATH_INSERT_BEFORE, jbvString, JsonbIteratorNext(), newval, push_path(), pushJsonbValue(), setPath(), JsonbValue::type, JsonbValue::val, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by setPath().

sn_array_element_start()

static JsonParseErrorType sn_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 4457 of file jsonfuncs.c.

{
    StripnullState *_state = (StripnullState *) state;
 
    /* If strip_in_arrays is enabled and this is a null, mark it for skipping */
    if (isnull && _state->strip_in_arrays)
    {
        _state->skip_next_null = true;
        return JSON_SUCCESS;
    }
 
    /* Only add a comma if this is not the first valid element */
    if (_state->strval->len > 0 &&
        _state->strval->data[_state->strval->len - 1] != '[')
    {
        appendStringInfoCharMacro(_state->strval, ',');
    }
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, StringInfoData::data, JSON_SUCCESS, StringInfoData::len, StripnullState::skip_next_null, StripnullState::strip_in_arrays, and StripnullState::strval.

Referenced by json_strip_nulls().

sn_array_end()

static JsonParseErrorType sn_array_end ( void *  state )

static

Definition at line 4417 of file jsonfuncs.c.

{
    StripnullState *_state = (StripnullState *) state;
 
    appendStringInfoCharMacro(_state->strval, ']');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, JSON_SUCCESS, and StripnullState::strval.

Referenced by json_strip_nulls().

sn_array_start()

static JsonParseErrorType sn_array_start ( void *  state )

static

Definition at line 4407 of file jsonfuncs.c.

{
    StripnullState *_state = (StripnullState *) state;
 
    appendStringInfoCharMacro(_state->strval, '[');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, JSON_SUCCESS, and StripnullState::strval.

Referenced by json_strip_nulls().

sn_object_end()

static JsonParseErrorType sn_object_end ( void *  state )

static

Definition at line 4397 of file jsonfuncs.c.

{
    StripnullState *_state = (StripnullState *) state;
 
    appendStringInfoCharMacro(_state->strval, '}');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, JSON_SUCCESS, and StripnullState::strval.

Referenced by json_strip_nulls().

sn_object_field_start()

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

static

Definition at line 4427 of file jsonfuncs.c.

{
    StripnullState *_state = (StripnullState *) state;
 
    if (isnull)
    {
        /*
         * The next thing must be a scalar or isnull couldn't be true, so
         * there is no danger of this state being carried down into a nested
         * object or array. The flag will be reset in the scalar action.
         */
        _state->skip_next_null = true;
        return JSON_SUCCESS;
    }
 
    if (_state->strval->data[_state->strval->len - 1] != '{')
        appendStringInfoCharMacro(_state->strval, ',');
 
    /*
     * Unfortunately we don't have the quoted and escaped string any more, so
     * we have to re-escape it.
     */
    escape_json(_state->strval, fname);
 
    appendStringInfoCharMacro(_state->strval, ':');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, StringInfoData::data, escape_json(), JSON_SUCCESS, StringInfoData::len, StripnullState::skip_next_null, and StripnullState::strval.

Referenced by json_strip_nulls().

sn_object_start()

static JsonParseErrorType sn_object_start ( void *  state )

static

Definition at line 4387 of file jsonfuncs.c.

{
    StripnullState *_state = (StripnullState *) state;
 
    appendStringInfoCharMacro(_state->strval, '{');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, JSON_SUCCESS, and StripnullState::strval.

Referenced by json_strip_nulls().

sn_scalar()

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

static

Definition at line 4479 of file jsonfuncs.c.

{
    StripnullState *_state = (StripnullState *) state;
 
    if (_state->skip_next_null)
    {
        Assert(tokentype == JSON_TOKEN_NULL);
        _state->skip_next_null = false;
        return JSON_SUCCESS;
    }
 
    if (tokentype == JSON_TOKEN_STRING)
        escape_json(_state->strval, token);
    else
        appendStringInfoString(_state->strval, token);
 
    return JSON_SUCCESS;
}

References appendStringInfoString(), Assert(), escape_json(), JSON_SUCCESS, JSON_TOKEN_NULL, JSON_TOKEN_STRING, StripnullState::skip_next_null, and StripnullState::strval.

Referenced by json_strip_nulls().

transform_json_string_values()

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

Definition at line 5819 of file jsonfuncs.c.

{
    JsonLexContext lex;
    JsonSemAction *sem = palloc0(sizeof(JsonSemAction));
    TransformJsonStringValuesState *state = palloc0(sizeof(TransformJsonStringValuesState));
    StringInfoData strbuf;
 
    initStringInfo(&strbuf);
 
    state->lex = makeJsonLexContext(&lex, json, true);
    state->strval = &strbuf;
    state->action = transform_action;
    state->action_state = action_state;
 
    sem->semstate = state;
    sem->object_start = transform_string_values_object_start;
    sem->object_end = transform_string_values_object_end;
    sem->array_start = transform_string_values_array_start;
    sem->array_end = transform_string_values_array_end;
    sem->scalar = transform_string_values_scalar;
    sem->array_element_start = transform_string_values_array_element_start;
    sem->object_field_start = transform_string_values_object_field_start;
 
    pg_parse_json_or_ereport(&lex, sem);
    freeJsonLexContext(&lex);
 
    return cstring_to_text_with_len(state->strval->data, state->strval->len);
}

References JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, cstring_to_text_with_len(), freeJsonLexContext(), initStringInfo(), makeJsonLexContext(), JsonSemAction::object_end, JsonSemAction::object_field_start, JsonSemAction::object_start, palloc0(), pg_parse_json_or_ereport, JsonSemAction::scalar, sem, JsonSemAction::semstate, transform_string_values_array_element_start(), transform_string_values_array_end(), transform_string_values_array_start(), transform_string_values_object_end(), transform_string_values_object_field_start(), transform_string_values_object_start(), and transform_string_values_scalar().

Referenced by ts_headline_json_byid_opt().

transform_jsonb_string_values()

Jsonb * transform_jsonb_string_values	(	Jsonb *	jsonb,
		void *	action_state,
		JsonTransformStringValuesAction	transform_action
	)

Definition at line 5773 of file jsonfuncs.c.

{
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken type;
    JsonbInState st = {0};
    text       *out;
    bool        is_scalar = false;
 
    it = JsonbIteratorInit(&jsonb->root);
    is_scalar = it->isScalar;
 
    while ((type = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        if ((type == WJB_VALUE || type == WJB_ELEM) && v.type == jbvString)
        {
            out = transform_action(action_state, v.val.string.val, v.val.string.len);
            /* out is probably not toasted, but let's be sure */
            out = pg_detoast_datum_packed(out);
            v.val.string.val = VARDATA_ANY(out);
            v.val.string.len = VARSIZE_ANY_EXHDR(out);
            pushJsonbValue(&st, type, type < WJB_BEGIN_ARRAY ? &v : NULL);
        }
        else
        {
            pushJsonbValue(&st, type, (type == WJB_KEY ||
                                       type == WJB_VALUE ||
                                       type == WJB_ELEM) ? &v : NULL);
        }
    }
 
    if (st.result->type == jbvArray)
        st.result->val.array.rawScalar = is_scalar;
 
    return JsonbValueToJsonb(st.result);
}

References JsonbIterator::isScalar, jbvArray, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), JsonbValueToJsonb(), pg_detoast_datum_packed(), pushJsonbValue(), JsonbInState::result, Jsonb::root, type, JsonbValue::type, JsonbValue::val, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), WJB_BEGIN_ARRAY, WJB_DONE, WJB_ELEM, WJB_KEY, and WJB_VALUE.

Referenced by ts_headline_jsonb_byid_opt().

transform_string_values_array_element_start()

static JsonParseErrorType transform_string_values_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 5913 of file jsonfuncs.c.

{
    TransformJsonStringValuesState *_state = (TransformJsonStringValuesState *) state;
 
    if (_state->strval->data[_state->strval->len - 1] != '[')
        appendStringInfoCharMacro(_state->strval, ',');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, StringInfoData::data, JSON_SUCCESS, StringInfoData::len, and TransformJsonStringValuesState::strval.

Referenced by transform_json_string_values().

transform_string_values_array_end()

static JsonParseErrorType transform_string_values_array_end ( void *  state )

static

Definition at line 5885 of file jsonfuncs.c.

{
    TransformJsonStringValuesState *_state = (TransformJsonStringValuesState *) state;
 
    appendStringInfoCharMacro(_state->strval, ']');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, JSON_SUCCESS, and TransformJsonStringValuesState::strval.

Referenced by transform_json_string_values().

transform_string_values_array_start()

static JsonParseErrorType transform_string_values_array_start ( void *  state )

static

Definition at line 5875 of file jsonfuncs.c.

{
    TransformJsonStringValuesState *_state = (TransformJsonStringValuesState *) state;
 
    appendStringInfoCharMacro(_state->strval, '[');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, JSON_SUCCESS, and TransformJsonStringValuesState::strval.

Referenced by transform_json_string_values().

transform_string_values_object_end()

static JsonParseErrorType transform_string_values_object_end ( void *  state )

static

Definition at line 5865 of file jsonfuncs.c.

{
    TransformJsonStringValuesState *_state = (TransformJsonStringValuesState *) state;
 
    appendStringInfoCharMacro(_state->strval, '}');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, JSON_SUCCESS, and TransformJsonStringValuesState::strval.

Referenced by transform_json_string_values().

transform_string_values_object_field_start()

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

static

Definition at line 5895 of file jsonfuncs.c.

{
    TransformJsonStringValuesState *_state = (TransformJsonStringValuesState *) state;
 
    if (_state->strval->data[_state->strval->len - 1] != '{')
        appendStringInfoCharMacro(_state->strval, ',');
 
    /*
     * Unfortunately we don't have the quoted and escaped string any more, so
     * we have to re-escape it.
     */
    escape_json(_state->strval, fname);
    appendStringInfoCharMacro(_state->strval, ':');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, StringInfoData::data, escape_json(), JSON_SUCCESS, StringInfoData::len, and TransformJsonStringValuesState::strval.

Referenced by transform_json_string_values().

transform_string_values_object_start()

static JsonParseErrorType transform_string_values_object_start ( void *  state )

static

Definition at line 5855 of file jsonfuncs.c.

{
    TransformJsonStringValuesState *_state = (TransformJsonStringValuesState *) state;
 
    appendStringInfoCharMacro(_state->strval, '{');
 
    return JSON_SUCCESS;
}

References appendStringInfoCharMacro, JSON_SUCCESS, and TransformJsonStringValuesState::strval.

Referenced by transform_json_string_values().

transform_string_values_scalar()

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

static

Definition at line 5924 of file jsonfuncs.c.

{
    TransformJsonStringValuesState *_state = (TransformJsonStringValuesState *) state;
 
    if (tokentype == JSON_TOKEN_STRING)
    {
        text       *out = _state->action(_state->action_state, token, strlen(token));
 
        escape_json_text(_state->strval, out);
    }
    else
        appendStringInfoString(_state->strval, token);
 
    return JSON_SUCCESS;
}

References TransformJsonStringValuesState::action, TransformJsonStringValuesState::action_state, appendStringInfoString(), escape_json_text(), JSON_SUCCESS, JSON_TOKEN_STRING, and TransformJsonStringValuesState::strval.

Referenced by transform_json_string_values().

update_cached_tupdesc()

static void update_cached_tupdesc ( CompositeIOData *  io, MemoryContext  mcxt  )

static

Definition at line 3026 of file jsonfuncs.c.

{
    if (!io->tupdesc ||
        io->tupdesc->tdtypeid != io->base_typid ||
        io->tupdesc->tdtypmod != io->base_typmod)
    {
        TupleDesc   tupdesc = lookup_rowtype_tupdesc(io->base_typid,
                                                     io->base_typmod);
        MemoryContext oldcxt;
 
        if (io->tupdesc)
            FreeTupleDesc(io->tupdesc);
 
        /* copy tuple desc without constraints into cache memory context */
        oldcxt = MemoryContextSwitchTo(mcxt);
        io->tupdesc = CreateTupleDescCopy(tupdesc);
        MemoryContextSwitchTo(oldcxt);
 
        ReleaseTupleDesc(tupdesc);
    }
}

References CompositeIOData::base_typid, CompositeIOData::base_typmod, CreateTupleDescCopy(), FreeTupleDesc(), lookup_rowtype_tupdesc(), MemoryContextSwitchTo(), ReleaseTupleDesc, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and CompositeIOData::tupdesc.

Referenced by populate_composite(), populate_recordset_record(), and populate_recordset_worker().