#include "postgres.h"
#include "executor/execExpr.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/subscripting.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:

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)

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 473 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 = (ArraySubWorkspace *) palloc(sizeof(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, get_typlen(), get_typlenbyvalalign(), MAXDIM, SubscriptingRefState::numlower, SubscriptingRefState::numupper, palloc(), ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ArraySubWorkspace::refelemtype, SubscriptExecSteps::sbs_assign, SubscriptExecSteps::sbs_check_subscripts, SubscriptExecSteps::sbs_fetch, SubscriptExecSteps::sbs_fetch_old, and SubscriptingRefState::workspace.

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 294 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, if(), SubscriptingRefState::numupper, PointerGetDatum(), ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ArraySubWorkspace::refelemtype, SubscriptingRefState::replacenull, SubscriptingRefState::replacevalue, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ArraySubWorkspace::upperindex, and SubscriptingRefState::workspace.

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 344 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, if(), ArraySubWorkspace::lowerindex, SubscriptingRefState::lowerprovided, SubscriptingRefState::numupper, PointerGetDatum(), ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ArraySubWorkspace::refelemtype, SubscriptingRefState::replacenull, SubscriptingRefState::replacevalue, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ArraySubWorkspace::upperindex, SubscriptingRefState::upperprovided, and SubscriptingRefState::workspace.

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

Referenced by array_exec_setup().

◆ array_subscript_fetch()

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

static

Definition at line 236 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, SubscriptingRefState::numupper, ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ArraySubWorkspace::upperindex, and SubscriptingRefState::workspace.

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 399 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, if(), SubscriptingRefState::numupper, SubscriptingRefState::prevnull, SubscriptingRefState::prevvalue, ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ArraySubWorkspace::upperindex, and SubscriptingRefState::workspace.

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 439 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, if(), ArraySubWorkspace::lowerindex, SubscriptingRefState::lowerprovided, SubscriptingRefState::numupper, SubscriptingRefState::prevnull, SubscriptingRefState::prevvalue, ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ArraySubWorkspace::upperindex, SubscriptingRefState::upperprovided, and SubscriptingRefState::workspace.

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 264 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, ArraySubWorkspace::lowerindex, SubscriptingRefState::lowerprovided, SubscriptingRefState::numupper, ArraySubWorkspace::refattrlength, ArraySubWorkspace::refelemalign, ArraySubWorkspace::refelembyval, ArraySubWorkspace::refelemlength, ExprEvalStep::resnull, ExprEvalStep::resvalue, ExprEvalStep::sbsref, ArraySubWorkspace::upperindex, SubscriptingRefState::upperprovided, and SubscriptingRefState::workspace.

Referenced by array_exec_setup().

◆ array_subscript_handler()

Datum array_subscript_handler ( PG_FUNCTION_ARGS )

Definition at line 539 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(), PG_RETURN_POINTER, and SubscriptRoutines::transform.

◆ array_subscript_transform()

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

static

Definition at line 55 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 SubscriptRef 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(), idx(), Int32GetDatum(), InvalidOid, A_Indices::is_slice, lappend(), lfirst_node, A_Indices::lidx, list_length(), makeConst(), MAXDIM, NIL, ParseState::p_expr_kind, parser_errposition(), SubscriptingRef::reflowerindexpr, SubscriptingRef::refupperindexpr, transformExpr(), and A_Indices::uidx.

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 566 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(), PG_RETURN_POINTER, and SubscriptRoutines::transform.

Data Structures

Typedefs

Functions

Typedef Documentation

◆ ArraySubWorkspace

Function Documentation

◆ array_exec_setup()

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

◆ array_subscript_handler()

◆ array_subscript_transform()

◆ raw_array_subscript_handler()