#include "postgres.h"
#include "executor/execExpr.h"
#include "nodes/nodeFuncs.h"
#include "nodes/subscripting.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "utils/builtins.h"
#include "utils/jsonb.h"

Include dependency graph for jsonbsubs.c:

Data Structures
struct	JsonbSubWorkspace

Typedefs
typedef struct JsonbSubWorkspace	JsonbSubWorkspace

Functions
static void	jsonb_subscript_transform (SubscriptingRef sbsref, List indirection, ParseState *pstate, bool isSlice, bool isAssignment)

static bool	jsonb_subscript_check_subscripts (ExprState state, ExprEvalStep op, ExprContext *econtext)

static void	jsonb_subscript_fetch (ExprState state, ExprEvalStep op, ExprContext *econtext)

static void	jsonb_subscript_assign (ExprState state, ExprEvalStep op, ExprContext *econtext)

static void	jsonb_subscript_fetch_old (ExprState state, ExprEvalStep op, ExprContext *econtext)

static void	jsonb_exec_setup (const SubscriptingRef sbsref, SubscriptingRefState sbsrefstate, SubscriptExecSteps *methods)

Datum	jsonb_subscript_handler (PG_FUNCTION_ARGS)

Typedef Documentation

◆ JsonbSubWorkspace

typedef struct JsonbSubWorkspace JsonbSubWorkspace

Function Documentation

◆ jsonb_exec_setup()

static void jsonb_exec_setup	(	const SubscriptingRef *	sbsref,
		SubscriptingRefState *	sbsrefstate,
		SubscriptExecSteps *	methods
	)

static

Definition at line 353 of file jsonbsubs.c.

{
    JsonbSubWorkspace *workspace;
    ListCell   *lc;
    int         nupper = sbsref->refupperindexpr->length;
    char       *ptr;
 
    /* Allocate type-specific workspace with space for per-subscript data */
    workspace = palloc0(MAXALIGN(sizeof(JsonbSubWorkspace)) +
                        nupper * (sizeof(Datum) + sizeof(Oid)));
    workspace->expectArray = false;
    ptr = ((char *) workspace) + MAXALIGN(sizeof(JsonbSubWorkspace));
 
    /*
     * This coding assumes sizeof(Datum) >= sizeof(Oid), else we might
     * misalign the indexOid pointer
     */
    workspace->index = (Datum *) ptr;
    ptr += nupper * sizeof(Datum);
    workspace->indexOid = (Oid *) ptr;
 
    sbsrefstate->workspace = workspace;
 
    /* Collect subscript data types necessary at execution time */
    foreach(lc, sbsref->refupperindexpr)
    {
        Node       *expr = lfirst(lc);
        int         i = foreach_current_index(lc);
 
        workspace->indexOid[i] = exprType(expr);
    }
 
    /*
     * Pass back pointers to appropriate step execution functions.
     */
    methods->sbs_check_subscripts = jsonb_subscript_check_subscripts;
    methods->sbs_fetch = jsonb_subscript_fetch;
    methods->sbs_assign = jsonb_subscript_assign;
    methods->sbs_fetch_old = jsonb_subscript_fetch_old;
}

References JsonbSubWorkspace::expectArray, exprType(), foreach_current_index, i, JsonbSubWorkspace::index, JsonbSubWorkspace::indexOid, jsonb_subscript_assign(), jsonb_subscript_check_subscripts(), jsonb_subscript_fetch(), jsonb_subscript_fetch_old(), List::length, lfirst, MAXALIGN, palloc0(), SubscriptingRef::refupperindexpr, SubscriptExecSteps::sbs_assign, SubscriptExecSteps::sbs_check_subscripts, SubscriptExecSteps::sbs_fetch, SubscriptExecSteps::sbs_fetch_old, and SubscriptingRefState::workspace.

Referenced by jsonb_subscript_handler().

◆ jsonb_subscript_assign()

static void jsonb_subscript_assign	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

static

Definition at line 261 of file jsonbsubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
    JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
    Jsonb      *jsonbSource;
    JsonbValue  replacevalue;
 
    if (sbsrefstate->replacenull)
        replacevalue.type = jbvNull;
    else
        JsonbToJsonbValue(DatumGetJsonbP(sbsrefstate->replacevalue),
                          &replacevalue);
 
    /*
     * In case if the input container is null, set up an empty jsonb and
     * proceed with the assignment.
     */
    if (*op->resnull)
    {
        JsonbValue  newSource;
 
        /*
         * To avoid any surprising results, set up an empty jsonb array in
         * case of an array is expected (i.e. the first subscript is integer),
         * otherwise jsonb object.
         */
        if (workspace->expectArray)
        {
            newSource.type = jbvArray;
            newSource.val.array.nElems = 0;
            newSource.val.array.rawScalar = false;
        }
        else
        {
            newSource.type = jbvObject;
            newSource.val.object.nPairs = 0;
        }
 
        jsonbSource = JsonbValueToJsonb(&newSource);
        *op->resnull = false;
    }
    else
        jsonbSource = DatumGetJsonbP(*op->resvalue);
 
    *op->resvalue = jsonb_set_element(jsonbSource,
                                      workspace->index,
                                      sbsrefstate->numupper,
                                      &replacevalue);
    /* The result is never NULL, so no need to change *op->resnull */
}

References ExprEvalStep::d, DatumGetJsonbP(), JsonbSubWorkspace::expectArray, if(), JsonbSubWorkspace::index, jbvArray, jbvNull, jbvObject, jsonb_set_element(), JsonbToJsonbValue(), JsonbValueToJsonb(), SubscriptingRefState::numupper, SubscriptingRefState::replacenull, SubscriptingRefState::replacevalue, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, JsonbValue::type, JsonbValue::val, and SubscriptingRefState::workspace.

Referenced by jsonb_exec_setup().

◆ jsonb_subscript_check_subscripts()

static bool jsonb_subscript_check_subscripts	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

static

Definition at line 175 of file jsonbsubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref_subscript.state;
    JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
 
    /*
     * In case if the first subscript is an integer, the source jsonb is
     * expected to be an array. This information is not used directly, all
     * such cases are handled within corresponding jsonb assign functions. But
     * if the source jsonb is NULL the expected type will be used to construct
     * an empty source.
     */
    if (sbsrefstate->numupper > 0 && sbsrefstate->upperprovided[0] &&
        !sbsrefstate->upperindexnull[0] && workspace->indexOid[0] == INT4OID)
        workspace->expectArray = true;
 
    /* Process upper subscripts */
    for (int i = 0; i < sbsrefstate->numupper; i++)
    {
        if (sbsrefstate->upperprovided[i])
        {
            /* If any index expr yields NULL, result is NULL or error */
            if (sbsrefstate->upperindexnull[i])
            {
                if (sbsrefstate->isassignment)
                    ereport(ERROR,
                            (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                             errmsg("jsonb subscript in assignment must not be null")));
                *op->resnull = true;
                return false;
            }
 
            /*
             * For jsonb fetch and assign functions we need to provide path in
             * text format. Convert if it's not already text.
             */
            if (workspace->indexOid[i] == INT4OID)
            {
                Datum       datum = sbsrefstate->upperindex[i];
                char       *cs = DatumGetCString(DirectFunctionCall1(int4out, datum));
 
                workspace->index[i] = CStringGetTextDatum(cs);
            }
            else
                workspace->index[i] = sbsrefstate->upperindex[i];
        }
    }
 
    return true;
}

References CStringGetTextDatum, ExprEvalStep::d, DatumGetCString(), DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, JsonbSubWorkspace::expectArray, i, if(), JsonbSubWorkspace::index, JsonbSubWorkspace::indexOid, int4out(), SubscriptingRefState::isassignment, SubscriptingRefState::numupper, ExprEvalStep::resnull, ExprEvalStep::sbsref_subscript, ExprEvalStep::state, SubscriptingRefState::upperindex, SubscriptingRefState::upperindexnull, SubscriptingRefState::upperprovided, and SubscriptingRefState::workspace.

Referenced by jsonb_exec_setup().

◆ jsonb_subscript_fetch()

static void jsonb_subscript_fetch	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

static

Definition at line 235 of file jsonbsubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
    JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
    Jsonb      *jsonbSource;
 
    /* Should not get here if source jsonb (or any subscript) is null */
    Assert(!(*op->resnull));
 
    jsonbSource = DatumGetJsonbP(*op->resvalue);
    *op->resvalue = jsonb_get_element(jsonbSource,
                                      workspace->index,
                                      sbsrefstate->numupper,
                                      op->resnull,
                                      false);
}

References Assert, ExprEvalStep::d, DatumGetJsonbP(), JsonbSubWorkspace::index, jsonb_get_element(), SubscriptingRefState::numupper, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, and SubscriptingRefState::workspace.

Referenced by jsonb_exec_setup().

◆ jsonb_subscript_fetch_old()

static void jsonb_subscript_fetch_old	(	ExprState *	state,
		ExprEvalStep *	op,
		ExprContext *	econtext
	)

static

Definition at line 323 of file jsonbsubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
 
    if (*op->resnull)
    {
        /* whole jsonb is null, so any element is too */
        sbsrefstate->prevvalue = (Datum) 0;
        sbsrefstate->prevnull = true;
    }
    else
    {
        Jsonb      *jsonbSource = DatumGetJsonbP(*op->resvalue);
 
        sbsrefstate->prevvalue = jsonb_get_element(jsonbSource,
                                                   sbsrefstate->upperindex,
                                                   sbsrefstate->numupper,
                                                   &sbsrefstate->prevnull,
                                                   false);
    }
}

References ExprEvalStep::d, DatumGetJsonbP(), jsonb_get_element(), SubscriptingRefState::numupper, SubscriptingRefState::prevnull, SubscriptingRefState::prevvalue, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, and SubscriptingRefState::upperindex.

Referenced by jsonb_exec_setup().

◆ jsonb_subscript_handler()

Datum jsonb_subscript_handler ( PG_FUNCTION_ARGS )

Definition at line 402 of file jsonbsubs.c.

{
    static const SubscriptRoutines sbsroutines = {
        .transform = jsonb_subscript_transform,
        .exec_setup = jsonb_exec_setup,
        .fetch_strict = true,   /* fetch returns NULL for NULL inputs */
        .fetch_leakproof = true,    /* fetch returns NULL for bad subscript */
        .store_leakproof = false    /* ... but assignment throws error */
    };
 
    PG_RETURN_POINTER(&sbsroutines);
}

References jsonb_exec_setup(), jsonb_subscript_transform(), PG_RETURN_POINTER, and SubscriptRoutines::transform.

◆ jsonb_subscript_transform()

static void jsonb_subscript_transform	(	SubscriptingRef *	sbsref,
		List *	indirection,
		ParseState *	pstate,
		bool	isSlice,
		bool	isAssignment
	)

static

Definition at line 43 of file jsonbsubs.c.

{
    List       *upperIndexpr = NIL;
    ListCell   *idx;
 
    /*
     * Transform and convert the subscript expressions. Jsonb subscripting
     * does not support slices, look only and the upper index.
     */
    foreach(idx, indirection)
    {
        A_Indices  *ai = lfirst_node(A_Indices, idx);
        Node       *subExpr;
 
        if (isSlice)
        {
            Node       *expr = ai->uidx ? ai->uidx : ai->lidx;
 
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("jsonb subscript does not support slices"),
                     parser_errposition(pstate, exprLocation(expr))));
        }
 
        if (ai->uidx)
        {
            Oid         subExprType = InvalidOid,
                        targetType = UNKNOWNOID;
 
            subExpr = transformExpr(pstate, ai->uidx, pstate->p_expr_kind);
            subExprType = exprType(subExpr);
 
            if (subExprType != UNKNOWNOID)
            {
                Oid         targets[2] = {INT4OID, TEXTOID};
 
                /*
                 * Jsonb can handle multiple subscript types, but cases when a
                 * subscript could be coerced to multiple target types must be
                 * avoided, similar to overloaded functions. It could be
                 * possibly extend with jsonpath in the future.
                 */
                for (int i = 0; i < 2; i++)
                {
                    if (can_coerce_type(1, &subExprType, &targets[i], COERCION_IMPLICIT))
                    {
                        /*
                         * One type has already succeeded, it means there are
                         * two coercion targets possible, failure.
                         */
                        if (targetType != UNKNOWNOID)
                            ereport(ERROR,
                                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                                     errmsg("subscript type %s is not supported", format_type_be(subExprType)),
                                     errhint("jsonb subscript must be coercible to only one type, integer or text."),
                                     parser_errposition(pstate, exprLocation(subExpr))));
 
                        targetType = targets[i];
                    }
                }
 
                /*
                 * No suitable types were found, failure.
                 */
                if (targetType == UNKNOWNOID)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("subscript type %s is not supported", format_type_be(subExprType)),
                             errhint("jsonb subscript must be coercible to either integer or text."),
                             parser_errposition(pstate, exprLocation(subExpr))));
            }
            else
                targetType = TEXTOID;
 
            /*
             * We known from can_coerce_type that coercion will succeed, so
             * coerce_type could be used. Note the implicit coercion context,
             * which is required to handle subscripts of different types,
             * similar to overloaded functions.
             */
            subExpr = coerce_type(pstate,
                                  subExpr, subExprType,
                                  targetType, -1,
                                  COERCION_IMPLICIT,
                                  COERCE_IMPLICIT_CAST,
                                  -1);
            if (subExpr == NULL)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("jsonb subscript must have text type"),
                         parser_errposition(pstate, exprLocation(subExpr))));
        }
        else
        {
            /*
             * Slice with omitted upper bound. Should not happen as we already
             * errored out on slice earlier, but handle this just in case.
             */
            Assert(isSlice && ai->is_slice);
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("jsonb subscript does not support slices"),
                     parser_errposition(pstate, exprLocation(ai->uidx))));
        }
 
        upperIndexpr = lappend(upperIndexpr, subExpr);
    }
 
    /* store the transformed lists into the SubscriptRef node */
    sbsref->refupperindexpr = upperIndexpr;
    sbsref->reflowerindexpr = NIL;
 
    /* Determine the result type of the subscripting operation; always jsonb */
    sbsref->refrestype = JSONBOID;
    sbsref->reftypmod = -1;
}

References Assert, can_coerce_type(), COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, ereport, errcode(), errhint(), errmsg(), ERROR, exprLocation(), exprType(), format_type_be(), i, idx(), InvalidOid, A_Indices::is_slice, lappend(), lfirst_node, A_Indices::lidx, NIL, ParseState::p_expr_kind, parser_errposition(), SubscriptingRef::reflowerindexpr, SubscriptingRef::refupperindexpr, transformExpr(), and A_Indices::uidx.

Referenced by jsonb_subscript_handler().

Data Structures

Typedefs

Functions

Typedef Documentation

◆ JsonbSubWorkspace

Function Documentation

◆ jsonb_exec_setup()

◆ jsonb_subscript_assign()

◆ jsonb_subscript_check_subscripts()

◆ jsonb_subscript_fetch()

◆ jsonb_subscript_fetch_old()

◆ jsonb_subscript_handler()

◆ jsonb_subscript_transform()