database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-17 06:41:09 +03:00
Code Activity

Renaming for new subscripting mechanism

Browse Source 
Over at patch https://commitfest.postgresql.org/21/1062/ Dmitry wants to
introduce a more generic subscription mechanism, which allows
subscripting not only arrays but also other object types such as JSONB.
That functionality is introduced in a largish invasive patch, out of
which this internal renaming patch was extracted.

Author: Dmitry Dolgov
Reviewed-by: Tom Lane, Arthur Zakirov
Discussion: https://postgr.es/m/CA+q6zcUK4EqPAu7XRRO5CCjMwhz5zvg+rfWuLzVoxp_5sKS6=w@mail.gmail.com
This commit is contained in:
Alvaro Herrera
2019-02-01 12:50:32 -03:00
parent f831d4accd
commit 558d77f20e
26 changed files with 555 additions and 523 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
src/backend/executor/execExprInterp.c
View File

@ -370,10 +370,10 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
&&CASE_EEOP_FIELDSELECT,
&&CASE_EEOP_FIELDSTORE_DEFORM,
&&CASE_EEOP_FIELDSTORE_FORM,
&&CASE_EEOP_ARRAYREF_SUBSCRIPT,
&&CASE_EEOP_ARRAYREF_OLD,
&&CASE_EEOP_ARRAYREF_ASSIGN,
&&CASE_EEOP_ARRAYREF_FETCH,
&&CASE_EEOP_SBSREF_SUBSCRIPT,
&&CASE_EEOP_SBSREF_OLD,
&&CASE_EEOP_SBSREF_ASSIGN,
&&CASE_EEOP_SBSREF_FETCH,
&&CASE_EEOP_DOMAIN_TESTVAL,
&&CASE_EEOP_DOMAIN_NOTNULL,
&&CASE_EEOP_DOMAIN_CHECK,
@ -1347,43 +1347,43 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
EEO_NEXT();
}
EEO_CASE(EEOP_ARRAYREF_SUBSCRIPT)
EEO_CASE(EEOP_SBSREF_SUBSCRIPT)
{
/* Process an array subscript */
/* too complex for an inline implementation */
if (ExecEvalArrayRefSubscript(state, op))
if (ExecEvalSubscriptingRef(state, op))
{
EEO_NEXT();
}
else
{
/* Subscript is null, short-circuit ArrayRef to NULL */
EEO_JUMP(op->d.arrayref_subscript.jumpdone);
/* Subscript is null, short-circuit SubscriptingRef to NULL */
EEO_JUMP(op->d.sbsref_subscript.jumpdone);
}
}
EEO_CASE(EEOP_ARRAYREF_OLD)
EEO_CASE(EEOP_SBSREF_OLD)
{
/*
* Fetch the old value in an arrayref assignment, in case it's
* Fetch the old value in an sbsref assignment, in case it's
* referenced (via a CaseTestExpr) inside the assignment
* expression.
*/
/* too complex for an inline implementation */
ExecEvalArrayRefOld(state, op);
ExecEvalSubscriptingRefOld(state, op);
EEO_NEXT();
}
/*
* Perform ArrayRef assignment
* Perform SubscriptingRef assignment
*/
EEO_CASE(EEOP_ARRAYREF_ASSIGN)
EEO_CASE(EEOP_SBSREF_ASSIGN)
{
/* too complex for an inline implementation */
ExecEvalArrayRefAssign(state, op);
ExecEvalSubscriptingRefAssign(state, op);
EEO_NEXT();
}
@ -1391,10 +1391,10 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
/*
* Fetch subset of an array.
*/
EEO_CASE(EEOP_ARRAYREF_FETCH)
EEO_CASE(EEOP_SBSREF_FETCH)
{
/* too complex for an inline implementation */
ExecEvalArrayRefFetch(state, op);
ExecEvalSubscriptingRefFetch(state, op);
EEO_NEXT();
}
@ -3044,27 +3044,27 @@ ExecEvalFieldStoreForm(ExprState *state, ExprEvalStep *op, ExprContext *econtext
}
/*
* Process a subscript in an ArrayRef expression.
* Process a subscript in a SubscriptingRef expression.
*
* If subscript is NULL, throw error in assignment case, or in fetch case
* set result to NULL and return false (instructing caller to skip the rest
* of the ArrayRef sequence).
* of the SubscriptingRef sequence).
*
* Subscript expression result is in subscriptvalue/subscriptnull.
* On success, integer subscript value has been saved in upperindex[] or
* lowerindex[] for use later.
*/
bool
ExecEvalArrayRefSubscript(ExprState *state, ExprEvalStep *op)
ExecEvalSubscriptingRef(ExprState *state, ExprEvalStep *op)
{
ArrayRefState *arefstate = op->d.arrayref_subscript.state;
SubscriptingRefState *sbsrefstate = op->d.sbsref_subscript.state;
int *indexes;
int off;
/* If any index expr yields NULL, result is NULL or error */
if (arefstate->subscriptnull)
if (sbsrefstate->subscriptnull)
{
if (arefstate->isassignment)
if (sbsrefstate->isassignment)
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("array subscript in assignment must not be null")));
@ -3073,124 +3073,124 @@ ExecEvalArrayRefSubscript(ExprState *state, ExprEvalStep *op)
}
/* Convert datum to int, save in appropriate place */
if (op->d.arrayref_subscript.isupper)
indexes = arefstate->upperindex;
if (op->d.sbsref_subscript.isupper)
indexes = sbsrefstate->upperindex;
else
indexes = arefstate->lowerindex;
off = op->d.arrayref_subscript.off;
indexes = sbsrefstate->lowerindex;
off = op->d.sbsref_subscript.off;
indexes[off] = DatumGetInt32(arefstate->subscriptvalue);
indexes[off] = DatumGetInt32(sbsrefstate->subscriptvalue);
return true;
}
/*
* Evaluate ArrayRef fetch.
* Evaluate SubscriptingRef fetch.
*
* Source array is in step's result variable.
* Source container is in step's result variable.
*/
void
ExecEvalArrayRefFetch(ExprState *state, ExprEvalStep *op)
ExecEvalSubscriptingRefFetch(ExprState *state, ExprEvalStep *op)
{
ArrayRefState *arefstate = op->d.arrayref.state;
SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
/* Should not get here if source array (or any subscript) is null */
/* Should not get here if source container (or any subscript) is null */
Assert(!(*op->resnull));
if (arefstate->numlower == 0)
if (sbsrefstate->numlower == 0)
{
/* Scalar case */
*op->resvalue = array_get_element(*op->resvalue,
arefstate->numupper,
arefstate->upperindex,
arefstate->refattrlength,
arefstate->refelemlength,
arefstate->refelembyval,
arefstate->refelemalign,
sbsrefstate->numupper,
sbsrefstate->upperindex,
sbsrefstate->refattrlength,
sbsrefstate->refelemlength,
sbsrefstate->refelembyval,
sbsrefstate->refelemalign,
op->resnull);
}
else
{
/* Slice case */
*op->resvalue = array_get_slice(*op->resvalue,
arefstate->numupper,
arefstate->upperindex,
arefstate->lowerindex,
arefstate->upperprovided,
arefstate->lowerprovided,
arefstate->refattrlength,
arefstate->refelemlength,
arefstate->refelembyval,
arefstate->refelemalign);
sbsrefstate->numupper,
sbsrefstate->upperindex,
sbsrefstate->lowerindex,
sbsrefstate->upperprovided,
sbsrefstate->lowerprovided,
sbsrefstate->refattrlength,
sbsrefstate->refelemlength,
sbsrefstate->refelembyval,
sbsrefstate->refelemalign);
}
}
/*
* Compute old array element/slice value for an ArrayRef assignment
* expression. Will only be generated if the new-value subexpression
* contains ArrayRef or FieldStore. The value is stored into the
* ArrayRefState's prevvalue/prevnull fields.
* Compute old container element/slice value for a SubscriptingRef assignment
* expression. Will only be generated if the new-value subexpression
* contains SubscriptingRef or FieldStore. The value is stored into the
* SubscriptingRefState's prevvalue/prevnull fields.
*/
void
ExecEvalArrayRefOld(ExprState *state, ExprEvalStep *op)
ExecEvalSubscriptingRefOld(ExprState *state, ExprEvalStep *op)
{
ArrayRefState *arefstate = op->d.arrayref.state;
SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
if (*op->resnull)
{
/* whole array is null, so any element or slice is too */
arefstate->prevvalue = (Datum) 0;
arefstate->prevnull = true;
sbsrefstate->prevvalue = (Datum) 0;
sbsrefstate->prevnull = true;
}
else if (arefstate->numlower == 0)
else if (sbsrefstate->numlower == 0)
{
/* Scalar case */
arefstate->prevvalue = array_get_element(*op->resvalue,
arefstate->numupper,
arefstate->upperindex,
arefstate->refattrlength,
arefstate->refelemlength,
arefstate->refelembyval,
arefstate->refelemalign,
&arefstate->prevnull);
sbsrefstate->prevvalue = array_get_element(*op->resvalue,
sbsrefstate->numupper,
sbsrefstate->upperindex,
sbsrefstate->refattrlength,
sbsrefstate->refelemlength,
sbsrefstate->refelembyval,
sbsrefstate->refelemalign,
&sbsrefstate->prevnull);
}
else
{
/* Slice case */
/* this is currently unreachable */
arefstate->prevvalue = array_get_slice(*op->resvalue,
arefstate->numupper,
arefstate->upperindex,
arefstate->lowerindex,
arefstate->upperprovided,
arefstate->lowerprovided,
arefstate->refattrlength,
arefstate->refelemlength,
arefstate->refelembyval,
arefstate->refelemalign);
arefstate->prevnull = false;
sbsrefstate->prevvalue = array_get_slice(*op->resvalue,
sbsrefstate->numupper,
sbsrefstate->upperindex,
sbsrefstate->lowerindex,
sbsrefstate->upperprovided,
sbsrefstate->lowerprovided,
sbsrefstate->refattrlength,
sbsrefstate->refelemlength,
sbsrefstate->refelembyval,
sbsrefstate->refelemalign);
sbsrefstate->prevnull = false;
}
}
/*
* Evaluate ArrayRef assignment.
* Evaluate SubscriptingRef assignment.
*
* Input array (possibly null) is in result area, replacement value is in
* ArrayRefState's replacevalue/replacenull.
* Input container (possibly null) is in result area, replacement value is in
* SubscriptingRefState's replacevalue/replacenull.
*/
void
ExecEvalArrayRefAssign(ExprState *state, ExprEvalStep *op)
ExecEvalSubscriptingRefAssign(ExprState *state, ExprEvalStep *op)
{
ArrayRefState *arefstate = op->d.arrayref.state;
SubscriptingRefState *sbsrefstate = op->d.sbsref_subscript.state;
/*
* 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.
* For an assignment to a fixed-length container type, both the original
* container and the value to be assigned into it must be non-NULL, else
* we punt and return the original container.
*/
if (arefstate->refattrlength > 0) /* fixed-length array? */
if (sbsrefstate->refattrlength > 0)
{
if (*op->resnull || arefstate->replacenull)
if (*op->resnull || sbsrefstate->replacenull)
return;
}
@ -3202,38 +3202,38 @@ ExecEvalArrayRefAssign(ExprState *state, ExprEvalStep *op)
*/
if (*op->resnull)
{
*op->resvalue = PointerGetDatum(construct_empty_array(arefstate->refelemtype));
*op->resvalue = PointerGetDatum(construct_empty_array(sbsrefstate->refelemtype));
*op->resnull = false;
}
if (arefstate->numlower == 0)
if (sbsrefstate->numlower == 0)
{
/* Scalar case */
*op->resvalue = array_set_element(*op->resvalue,
arefstate->numupper,
arefstate->upperindex,
arefstate->replacevalue,
arefstate->replacenull,
arefstate->refattrlength,
arefstate->refelemlength,
arefstate->refelembyval,
arefstate->refelemalign);
sbsrefstate->numupper,
sbsrefstate->upperindex,
sbsrefstate->replacevalue,
sbsrefstate->replacenull,
sbsrefstate->refattrlength,
sbsrefstate->refelemlength,
sbsrefstate->refelembyval,
sbsrefstate->refelemalign);
}
else
{
/* Slice case */
*op->resvalue = array_set_slice(*op->resvalue,
arefstate->numupper,
arefstate->upperindex,
arefstate->lowerindex,
arefstate->upperprovided,
arefstate->lowerprovided,
arefstate->replacevalue,
arefstate->replacenull,
arefstate->refattrlength,
arefstate->refelemlength,
arefstate->refelembyval,
arefstate->refelemalign);
sbsrefstate->numupper,
sbsrefstate->upperindex,
sbsrefstate->lowerindex,
sbsrefstate->upperprovided,
sbsrefstate->lowerprovided,
sbsrefstate->replacevalue,
sbsrefstate->replacenull,
sbsrefstate->refattrlength,
sbsrefstate->refelemlength,
sbsrefstate->refelembyval,
sbsrefstate->refelemalign);
}
}