arraysubs.c File Reference

#include "postgres.h"
#include "catalog/pg_type_d.h"
#include "executor/execExpr.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/subscripting.h"
#include "nodes/supportnodes.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "utils/array.h"
#include "utils/fmgrprotos.h"
#include "utils/lsyscache.h"

Include dependency graph for arraysubs.c:

Go to the source code of this file.

Data Structures
struct	ArraySubWorkspace

Typedefs
typedef struct ArraySubWorkspace	ArraySubWorkspace

Functions
static void	array_subscript_transform (SubscriptingRef *sbsref, List *indirection, ParseState *pstate, bool isSlice, bool isAssignment)
static bool	array_subscript_check_subscripts (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
static void	array_subscript_fetch (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
static void	array_subscript_fetch_slice (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
static void	array_subscript_assign (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
static void	array_subscript_assign_slice (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
static void	array_subscript_fetch_old (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
static void	array_subscript_fetch_old_slice (ExprState *state, ExprEvalStep *op, ExprContext *econtext)
static void	array_exec_setup (const SubscriptingRef *sbsref, SubscriptingRefState *sbsrefstate, SubscriptExecSteps *methods)
Datum	array_subscript_handler (PG_FUNCTION_ARGS)
Datum	raw_array_subscript_handler (PG_FUNCTION_ARGS)
Datum	array_subscript_handler_support (PG_FUNCTION_ARGS)

Typedef Documentation

ArraySubWorkspace

typedef struct ArraySubWorkspace ArraySubWorkspace

Function Documentation

array_exec_setup()

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

static

Definition at line 475 of file arraysubs.c.

{
    bool        is_slice = (sbsrefstate->numlower != 0);
    ArraySubWorkspace *workspace;
 
    /*
     * Enforce the implementation limit on number of array subscripts.  This
     * check isn't entirely redundant with checking at parse time; conceivably
     * the expression was stored by a backend with a different MAXDIM value.
     */
    if (sbsrefstate->numupper > MAXDIM)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
                        sbsrefstate->numupper, MAXDIM)));
 
    /* Should be impossible if parser is sane, but check anyway: */
    if (sbsrefstate->numlower != 0 &&
        sbsrefstate->numupper != sbsrefstate->numlower)
        elog(ERROR, "upper and lower index lists are not same length");
 
    /*
     * Allocate type-specific workspace.
     */
    workspace = palloc_object(ArraySubWorkspace);
    sbsrefstate->workspace = workspace;
 
    /*
     * Collect datatype details we'll need at execution.
     */
    workspace->refelemtype = sbsref->refelemtype;
    workspace->refattrlength = get_typlen(sbsref->refcontainertype);
    get_typlenbyvalalign(sbsref->refelemtype,
                         &workspace->refelemlength,
                         &workspace->refelembyval,
                         &workspace->refelemalign);
 
    /*
     * Pass back pointers to appropriate step execution functions.
     */
    methods->sbs_check_subscripts = array_subscript_check_subscripts;
    if (is_slice)
    {
        methods->sbs_fetch = array_subscript_fetch_slice;
        methods->sbs_assign = array_subscript_assign_slice;
        methods->sbs_fetch_old = array_subscript_fetch_old_slice;
    }
    else
    {
        methods->sbs_fetch = array_subscript_fetch;
        methods->sbs_assign = array_subscript_assign;
        methods->sbs_fetch_old = array_subscript_fetch_old;
    }
}

References array_subscript_assign(), array_subscript_assign_slice(), array_subscript_check_subscripts(), array_subscript_fetch(), array_subscript_fetch_old(), array_subscript_fetch_old_slice(), array_subscript_fetch_slice(), elog, ereport, errcode(), errmsg, ERROR, fb(), get_typlen(), get_typlenbyvalalign(), MAXDIM, palloc_object, ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ArraySubWorkspace::refelemtype, SubscriptExecSteps::sbs_assign, SubscriptExecSteps::sbs_check_subscripts, SubscriptExecSteps::sbs_fetch, and SubscriptExecSteps::sbs_fetch_old.

Referenced by array_subscript_handler(), and raw_array_subscript_handler().

array_subscript_assign()

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

static

Definition at line 296 of file arraysubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
    ArraySubWorkspace *workspace = (ArraySubWorkspace *) sbsrefstate->workspace;
    Datum       arraySource = *op->resvalue;
 
    /*
     * For an assignment to a fixed-length array type, both the original array
     * and the value to be assigned into it must be non-NULL, else we punt and
     * return the original array.
     */
    if (workspace->refattrlength > 0)
    {
        if (*op->resnull || sbsrefstate->replacenull)
            return;
    }
 
    /*
     * For assignment to varlena arrays, we handle a NULL original array by
     * substituting an empty (zero-dimensional) array; insertion of the new
     * element will result in a singleton array value.  It does not matter
     * whether the new element is NULL.
     */
    if (*op->resnull)
    {
        arraySource = PointerGetDatum(construct_empty_array(workspace->refelemtype));
        *op->resnull = false;
    }
 
    *op->resvalue = array_set_element(arraySource,
                                      sbsrefstate->numupper,
                                      workspace->upperindex,
                                      sbsrefstate->replacevalue,
                                      sbsrefstate->replacenull,
                                      workspace->refattrlength,
                                      workspace->refelemlength,
                                      workspace->refelembyval,
                                      workspace->refelemalign);
    /* The result is never NULL, so no need to change *op->resnull */
}

References array_set_element(), construct_empty_array(), ExprEvalStep::d, fb(), PointerGetDatum(), ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ArraySubWorkspace::refelemtype, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, and ArraySubWorkspace::upperindex.

Referenced by array_exec_setup().

array_subscript_assign_slice()

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

static

Definition at line 346 of file arraysubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
    ArraySubWorkspace *workspace = (ArraySubWorkspace *) sbsrefstate->workspace;
    Datum       arraySource = *op->resvalue;
 
    /*
     * For an assignment to a fixed-length array type, both the original array
     * and the value to be assigned into it must be non-NULL, else we punt and
     * return the original array.
     */
    if (workspace->refattrlength > 0)
    {
        if (*op->resnull || sbsrefstate->replacenull)
            return;
    }
 
    /*
     * For assignment to varlena arrays, we handle a NULL original array by
     * substituting an empty (zero-dimensional) array; insertion of the new
     * element will result in a singleton array value.  It does not matter
     * whether the new element is NULL.
     */
    if (*op->resnull)
    {
        arraySource = PointerGetDatum(construct_empty_array(workspace->refelemtype));
        *op->resnull = false;
    }
 
    *op->resvalue = array_set_slice(arraySource,
                                    sbsrefstate->numupper,
                                    workspace->upperindex,
                                    workspace->lowerindex,
                                    sbsrefstate->upperprovided,
                                    sbsrefstate->lowerprovided,
                                    sbsrefstate->replacevalue,
                                    sbsrefstate->replacenull,
                                    workspace->refattrlength,
                                    workspace->refelemlength,
                                    workspace->refelembyval,
                                    workspace->refelemalign);
    /* The result is never NULL, so no need to change *op->resnull */
}

References array_set_slice(), construct_empty_array(), ExprEvalStep::d, fb(), ArraySubWorkspace::lowerindex, PointerGetDatum(), ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ArraySubWorkspace::refelemtype, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, and ArraySubWorkspace::upperindex.

Referenced by array_exec_setup().

array_subscript_check_subscripts()

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

static

Definition at line 182 of file arraysubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref_subscript.state;
    ArraySubWorkspace *workspace = (ArraySubWorkspace *) sbsrefstate->workspace;
 
    /* 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("array subscript in assignment must not be null")));
                *op->resnull = true;
                return false;
            }
            workspace->upperindex[i] = DatumGetInt32(sbsrefstate->upperindex[i]);
        }
    }
 
    /* Likewise for lower subscripts */
    for (int i = 0; i < sbsrefstate->numlower; i++)
    {
        if (sbsrefstate->lowerprovided[i])
        {
            /* If any index expr yields NULL, result is NULL or error */
            if (sbsrefstate->lowerindexnull[i])
            {
                if (sbsrefstate->isassignment)
                    ereport(ERROR,
                            (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                             errmsg("array subscript in assignment must not be null")));
                *op->resnull = true;
                return false;
            }
            workspace->lowerindex[i] = DatumGetInt32(sbsrefstate->lowerindex[i]);
        }
    }
 
    return true;
}

References ExprEvalStep::d, DatumGetInt32(), ereport, errcode(), errmsg, ERROR, fb(), i, ArraySubWorkspace::lowerindex, ExprEvalStep::resnull, ExprEvalStep::sbsref_subscript, ExprEvalStep::state, and ArraySubWorkspace::upperindex.

Referenced by array_exec_setup().

array_subscript_fetch()

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

static

Definition at line 238 of file arraysubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
    ArraySubWorkspace *workspace = (ArraySubWorkspace *) sbsrefstate->workspace;
 
    /* Should not get here if source array (or any subscript) is null */
    Assert(!(*op->resnull));
 
    *op->resvalue = array_get_element(*op->resvalue,
                                      sbsrefstate->numupper,
                                      workspace->upperindex,
                                      workspace->refattrlength,
                                      workspace->refelemlength,
                                      workspace->refelembyval,
                                      workspace->refelemalign,
                                      op->resnull);
}

References array_get_element(), Assert, ExprEvalStep::d, fb(), ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, and ArraySubWorkspace::upperindex.

Referenced by array_exec_setup().

array_subscript_fetch_old()

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

static

Definition at line 401 of file arraysubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
    ArraySubWorkspace *workspace = (ArraySubWorkspace *) sbsrefstate->workspace;
 
    if (*op->resnull)
    {
        /* whole array is null, so any element is too */
        sbsrefstate->prevvalue = (Datum) 0;
        sbsrefstate->prevnull = true;
    }
    else
        sbsrefstate->prevvalue = array_get_element(*op->resvalue,
                                                   sbsrefstate->numupper,
                                                   workspace->upperindex,
                                                   workspace->refattrlength,
                                                   workspace->refelemlength,
                                                   workspace->refelembyval,
                                                   workspace->refelemalign,
                                                   &sbsrefstate->prevnull);
}

References array_get_element(), ExprEvalStep::d, fb(), ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, and ArraySubWorkspace::upperindex.

Referenced by array_exec_setup().

array_subscript_fetch_old_slice()

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

static

Definition at line 441 of file arraysubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
    ArraySubWorkspace *workspace = (ArraySubWorkspace *) sbsrefstate->workspace;
 
    if (*op->resnull)
    {
        /* whole array is null, so any slice is too */
        sbsrefstate->prevvalue = (Datum) 0;
        sbsrefstate->prevnull = true;
    }
    else
    {
        sbsrefstate->prevvalue = array_get_slice(*op->resvalue,
                                                 sbsrefstate->numupper,
                                                 workspace->upperindex,
                                                 workspace->lowerindex,
                                                 sbsrefstate->upperprovided,
                                                 sbsrefstate->lowerprovided,
                                                 workspace->refattrlength,
                                                 workspace->refelemlength,
                                                 workspace->refelembyval,
                                                 workspace->refelemalign);
        /* slices of non-null arrays are never null */
        sbsrefstate->prevnull = false;
    }
}

References array_get_slice(), ExprEvalStep::d, fb(), ArraySubWorkspace::lowerindex, ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, and ArraySubWorkspace::upperindex.

Referenced by array_exec_setup().

array_subscript_fetch_slice()

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

static

Definition at line 266 of file arraysubs.c.

{
    SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
    ArraySubWorkspace *workspace = (ArraySubWorkspace *) sbsrefstate->workspace;
 
    /* Should not get here if source array (or any subscript) is null */
    Assert(!(*op->resnull));
 
    *op->resvalue = array_get_slice(*op->resvalue,
                                    sbsrefstate->numupper,
                                    workspace->upperindex,
                                    workspace->lowerindex,
                                    sbsrefstate->upperprovided,
                                    sbsrefstate->lowerprovided,
                                    workspace->refattrlength,
                                    workspace->refelemlength,
                                    workspace->refelembyval,
                                    workspace->refelemalign);
    /* The slice is never NULL, so no need to change *op->resnull */
}

References array_get_slice(), Assert, ExprEvalStep::d, fb(), ArraySubWorkspace::lowerindex, ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ExprEvalStep::state, and ArraySubWorkspace::upperindex.

Referenced by array_exec_setup().

array_subscript_handler()

Datum array_subscript_handler

(

PG_FUNCTION_ARGS

)

Definition at line 541 of file arraysubs.c.

{
    static const SubscriptRoutines sbsroutines = {
        .transform = array_subscript_transform,
        .exec_setup = array_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 array_exec_setup(), array_subscript_transform(), fb(), PG_RETURN_POINTER, and SubscriptRoutines::transform.

array_subscript_handler_support()

Datum array_subscript_handler_support

(

PG_FUNCTION_ARGS

)

Definition at line 587 of file arraysubs.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestModifyInPlace))
    {
        /*
         * We can optimize in-place subscripted assignment if the refexpr is
         * the array being assigned to.  We don't need to worry about array
         * references within the refassgnexpr or the subscripts; however, if
         * there's no refassgnexpr then it's a fetch which there's no need to
         * optimize.
         */
        SupportRequestModifyInPlace *req = (SupportRequestModifyInPlace *) rawreq;
        Param      *refexpr = (Param *) linitial(req->args);
 
        if (refexpr && IsA(refexpr, Param) &&
            refexpr->paramkind == PARAM_EXTERN &&
            refexpr->paramid == req->paramid &&
            lsecond(req->args) != NULL)
            ret = (Node *) refexpr;
    }
 
    PG_RETURN_POINTER(ret);
}

References fb(), IsA, linitial, lsecond, PARAM_EXTERN, Param::paramid, Param::paramkind, PG_GETARG_POINTER, and PG_RETURN_POINTER.

array_subscript_transform()

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

static

Definition at line 57 of file arraysubs.c.

{
    List       *upperIndexpr = NIL;
    List       *lowerIndexpr = NIL;
    ListCell   *idx;
 
    /*
     * Transform the subscript expressions, and separate upper and lower
     * bounds into two lists.
     *
     * If we have a container slice expression, we convert any non-slice
     * indirection items to slices by treating the single subscript as the
     * upper bound and supplying an assumed lower bound of 1.
     */
    foreach(idx, indirection)
    {
        A_Indices  *ai = lfirst_node(A_Indices, idx);
        Node       *subexpr;
 
        if (isSlice)
        {
            if (ai->lidx)
            {
                subexpr = transformExpr(pstate, ai->lidx, pstate->p_expr_kind);
                /* If it's not int4 already, try to coerce */
                subexpr = coerce_to_target_type(pstate,
                                                subexpr, exprType(subexpr),
                                                INT4OID, -1,
                                                COERCION_ASSIGNMENT,
                                                COERCE_IMPLICIT_CAST,
                                                -1);
                if (subexpr == NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("array subscript must have type integer"),
                             parser_errposition(pstate, exprLocation(ai->lidx))));
            }
            else if (!ai->is_slice)
            {
                /* Make a constant 1 */
                subexpr = (Node *) makeConst(INT4OID,
                                             -1,
                                             InvalidOid,
                                             sizeof(int32),
                                             Int32GetDatum(1),
                                             false,
                                             true); /* pass by value */
            }
            else
            {
                /* Slice with omitted lower bound, put NULL into the list */
                subexpr = NULL;
            }
            lowerIndexpr = lappend(lowerIndexpr, subexpr);
        }
        else
            Assert(ai->lidx == NULL && !ai->is_slice);
 
        if (ai->uidx)
        {
            subexpr = transformExpr(pstate, ai->uidx, pstate->p_expr_kind);
            /* If it's not int4 already, try to coerce */
            subexpr = coerce_to_target_type(pstate,
                                            subexpr, exprType(subexpr),
                                            INT4OID, -1,
                                            COERCION_ASSIGNMENT,
                                            COERCE_IMPLICIT_CAST,
                                            -1);
            if (subexpr == NULL)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("array subscript must have type integer"),
                         parser_errposition(pstate, exprLocation(ai->uidx))));
        }
        else
        {
            /* Slice with omitted upper bound, put NULL into the list */
            Assert(isSlice && ai->is_slice);
            subexpr = NULL;
        }
        upperIndexpr = lappend(upperIndexpr, subexpr);
    }
 
    /* ... and store the transformed lists into the SubscriptingRef node */
    sbsref->refupperindexpr = upperIndexpr;
    sbsref->reflowerindexpr = lowerIndexpr;
 
    /* Verify subscript list lengths are within implementation limit */
    if (list_length(upperIndexpr) > MAXDIM)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
                        list_length(upperIndexpr), MAXDIM)));
    /* We need not check lowerIndexpr separately */
 
    /*
     * Determine the result type of the subscripting operation.  It's the same
     * as the array type if we're slicing, else it's the element type.  In
     * either case, the typmod is the same as the array's, so we need not
     * change reftypmod.
     */
    if (isSlice)
        sbsref->refrestype = sbsref->refcontainertype;
    else
        sbsref->refrestype = sbsref->refelemtype;
}

References Assert, COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, ereport, errcode(), errmsg, ERROR, exprLocation(), exprType(), fb(), idx(), Int32GetDatum(), InvalidOid, lappend(), lfirst_node, list_length(), makeConst(), MAXDIM, NIL, ParseState::p_expr_kind, parser_errposition(), SubscriptingRef::reflowerindexpr, SubscriptingRef::refupperindexpr, and transformExpr().

Referenced by array_subscript_handler(), and raw_array_subscript_handler().

raw_array_subscript_handler()

Datum raw_array_subscript_handler

(

PG_FUNCTION_ARGS

)

Definition at line 568 of file arraysubs.c.

{
    static const SubscriptRoutines sbsroutines = {
        .transform = array_subscript_transform,
        .exec_setup = array_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 array_exec_setup(), array_subscript_transform(), fb(), PG_RETURN_POINTER, and SubscriptRoutines::transform.