array.h File Reference

#include "fmgr.h"
#include "utils/expandeddatum.h"

Include dependency graph for array.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ArrayType
struct	ExpandedArrayHeader
union	AnyArrayType
struct	ArrayBuildState
struct	ArrayBuildStateArr
struct	ArrayBuildStateAny
struct	ArrayMetaState
struct	ArrayMapState

Macros
#define	MAXDIM   6
#define	MaxArraySize   ((Size) (MaxAllocSize / sizeof(Datum)))
#define	EA_MAGIC   689375833 /* ID for debugging crosschecks */
#define	DatumGetArrayTypeP(X)   ((ArrayType *) PG_DETOAST_DATUM(X))
#define	DatumGetArrayTypePCopy(X)   ((ArrayType *) PG_DETOAST_DATUM_COPY(X))
#define	PG_GETARG_ARRAYTYPE_P(n)   DatumGetArrayTypeP(PG_GETARG_DATUM(n))
#define	PG_GETARG_ARRAYTYPE_P_COPY(n)   DatumGetArrayTypePCopy(PG_GETARG_DATUM(n))
#define	PG_RETURN_ARRAYTYPE_P(x)   PG_RETURN_POINTER(x)
#define	PG_GETARG_EXPANDED_ARRAY(n)   DatumGetExpandedArray(PG_GETARG_DATUM(n))
#define	PG_GETARG_EXPANDED_ARRAYX(n, metacache)    DatumGetExpandedArrayX(PG_GETARG_DATUM(n), metacache)
#define	PG_RETURN_EXPANDED_ARRAY(x)   PG_RETURN_DATUM(EOHPGetRWDatum(&(x)->hdr))
#define	PG_GETARG_ANY_ARRAY_P(n)   DatumGetAnyArrayP(PG_GETARG_DATUM(n))
#define	ARR_SIZE(a)   VARSIZE(a)
#define	ARR_NDIM(a)   ((a)->ndim)
#define	ARR_HASNULL(a)   ((a)->dataoffset != 0)
#define	ARR_ELEMTYPE(a)   ((a)->elemtype)
#define	ARR_DIMS(a)    ((int *) (((char *) (a)) + sizeof(ArrayType)))
#define	ARR_LBOUND(a)
#define	ARR_NULLBITMAP(a)
#define	ARR_OVERHEAD_NONULLS(ndims)    MAXALIGN(sizeof(ArrayType) + 2 * sizeof(int) * (ndims))
#define	ARR_OVERHEAD_WITHNULLS(ndims, nitems)
#define	ARR_DATA_OFFSET(a)    (ARR_HASNULL(a) ? (a)->dataoffset : ARR_OVERHEAD_NONULLS(ARR_NDIM(a)))
#define	ARR_DATA_PTR(a)    (((char *) (a)) + ARR_DATA_OFFSET(a))
#define	AARR_NDIM(a)
#define	AARR_HASNULL(a)
#define	AARR_ELEMTYPE(a)
#define	AARR_DIMS(a)
#define	AARR_LBOUND(a)

Typedefs
typedef struct ExprState	ExprState
typedef struct ExprContext	ExprContext
typedef struct ArrayType	ArrayType
typedef struct ExpandedArrayHeader	ExpandedArrayHeader
typedef union AnyArrayType	AnyArrayType
typedef struct ArrayBuildState	ArrayBuildState
typedef struct ArrayBuildStateArr	ArrayBuildStateArr
typedef struct ArrayBuildStateAny	ArrayBuildStateAny
typedef struct ArrayMetaState	ArrayMetaState
typedef struct ArrayMapState	ArrayMapState
typedef struct ArrayIteratorData *	ArrayIterator

Functions
void	CopyArrayEls (ArrayType *array, const Datum *values, const bool *nulls, int nitems, int typlen, bool typbyval, char typalign, bool freedata)
Datum	array_get_element (Datum arraydatum, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Datum	array_set_element (Datum arraydatum, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Datum	array_get_slice (Datum arraydatum, int nSubscripts, int *upperIndx, int *lowerIndx, bool *upperProvided, bool *lowerProvided, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Datum	array_set_slice (Datum arraydatum, int nSubscripts, int *upperIndx, int *lowerIndx, bool *upperProvided, bool *lowerProvided, Datum srcArrayDatum, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Datum	array_ref (ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
ArrayType *	array_set (ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Datum	array_map (Datum arrayd, ExprState *exprstate, ExprContext *econtext, Oid retType, ArrayMapState *amstate)
void	array_bitmap_copy (bits8 *destbitmap, int destoffset, const bits8 *srcbitmap, int srcoffset, int nitems)
ArrayType *	construct_array (Datum *elems, int nelems, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
ArrayType *	construct_array_builtin (Datum *elems, int nelems, Oid elmtype)
ArrayType *	construct_md_array (Datum *elems, bool *nulls, int ndims, int *dims, int *lbs, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
ArrayType *	construct_empty_array (Oid elmtype)
ExpandedArrayHeader *	construct_empty_expanded_array (Oid element_type, MemoryContext parentcontext, ArrayMetaState *metacache)
void	deconstruct_array (const ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
void	deconstruct_array_builtin (const ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
bool	array_contains_nulls (const ArrayType *array)
ArrayBuildState *	initArrayResult (Oid element_type, MemoryContext rcontext, bool subcontext)
ArrayBuildState *	initArrayResultWithSize (Oid element_type, MemoryContext rcontext, bool subcontext, int initsize)
ArrayBuildState *	accumArrayResult (ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Datum	makeArrayResult (ArrayBuildState *astate, MemoryContext rcontext)
Datum	makeMdArrayResult (ArrayBuildState *astate, int ndims, int *dims, int *lbs, MemoryContext rcontext, bool release)
ArrayBuildStateArr *	initArrayResultArr (Oid array_type, Oid element_type, MemoryContext rcontext, bool subcontext)
ArrayBuildStateArr *	accumArrayResultArr (ArrayBuildStateArr *astate, Datum dvalue, bool disnull, Oid array_type, MemoryContext rcontext)
Datum	makeArrayResultArr (ArrayBuildStateArr *astate, MemoryContext rcontext, bool release)
ArrayBuildStateAny *	initArrayResultAny (Oid input_type, MemoryContext rcontext, bool subcontext)
ArrayBuildStateAny *	accumArrayResultAny (ArrayBuildStateAny *astate, Datum dvalue, bool disnull, Oid input_type, MemoryContext rcontext)
Datum	makeArrayResultAny (ArrayBuildStateAny *astate, MemoryContext rcontext, bool release)
ArrayIterator	array_create_iterator (ArrayType *arr, int slice_ndim, ArrayMetaState *mstate)
bool	array_iterate (ArrayIterator iterator, Datum *value, bool *isnull)
void	array_free_iterator (ArrayIterator iterator)
int	ArrayGetOffset (int n, const int *dim, const int *lb, const int *indx)
int	ArrayGetNItems (int ndim, const int *dims)
int	ArrayGetNItemsSafe (int ndim, const int *dims, struct Node *escontext)
void	ArrayCheckBounds (int ndim, const int *dims, const int *lb)
bool	ArrayCheckBoundsSafe (int ndim, const int *dims, const int *lb, struct Node *escontext)
void	mda_get_range (int n, int *span, const int *st, const int *endp)
void	mda_get_prod (int n, const int *range, int *prod)
void	mda_get_offset_values (int n, int *dist, const int *prod, const int *span)
int	mda_next_tuple (int n, int *curr, const int *span)
int32 *	ArrayGetIntegerTypmods (ArrayType *arr, int *n)
Datum	expand_array (Datum arraydatum, MemoryContext parentcontext, ArrayMetaState *metacache)
ExpandedArrayHeader *	DatumGetExpandedArray (Datum d)
ExpandedArrayHeader *	DatumGetExpandedArrayX (Datum d, ArrayMetaState *metacache)
AnyArrayType *	DatumGetAnyArrayP (Datum d)
void	deconstruct_expanded_array (ExpandedArrayHeader *eah)

Variables
PGDLLIMPORT bool	Array_nulls

Macro Definition Documentation

AARR_DIMS

#define AARR_DIMS

(

a

)

Value:

    (VARATT_IS_EXPANDED_HEADER(a) ? \
     (a)->xpn.dims : ARR_DIMS((ArrayType *) (a)))

Definition at line 338 of file array.h.

                   : ARR_DIMS((ArrayType *) (a)))

AARR_ELEMTYPE

#define AARR_ELEMTYPE

(

a

)

Value:

    (VARATT_IS_EXPANDED_HEADER(a) ? \
     (a)->xpn.element_type : ARR_ELEMTYPE((ArrayType *) (a)))

Definition at line 335 of file array.h.

                           : ARR_ELEMTYPE((ArrayType *) (a)))

AARR_HASNULL

#define AARR_HASNULL

(

a

)

Value:

    (VARATT_IS_EXPANDED_HEADER(a) ? \
     ((a)->xpn.dvalues != NULL ? (a)->xpn.dnulls != NULL : ARR_HASNULL((a)->xpn.fvalue)) : \
     ARR_HASNULL((ArrayType *) (a)))

Definition at line 331 of file array.h.

                                                         : ARR_HASNULL((a)->xpn.fvalue)) : \
     ARR_HASNULL((ArrayType *) (a)))

AARR_LBOUND

#define AARR_LBOUND

(

a

)

Value:

    (VARATT_IS_EXPANDED_HEADER(a) ? \
     (a)->xpn.lbound : ARR_LBOUND((ArrayType *) (a)))

Definition at line 341 of file array.h.

                     : ARR_LBOUND((ArrayType *) (a)))

AARR_NDIM

#define AARR_NDIM

(

a

)

Value:

    (VARATT_IS_EXPANDED_HEADER(a) ? \
     (a)->xpn.ndims : ARR_NDIM((ArrayType *) (a)))

Definition at line 328 of file array.h.

                    : ARR_NDIM((ArrayType *) (a)))

ARR_DATA_OFFSET

#define ARR_DATA_OFFSET

(

a

)

(ARR_HASNULL(a) ? (a)->dataoffset : ARR_OVERHEAD_NONULLS(ARR_NDIM(a)))

Definition at line 316 of file array.h.

                                          : ARR_OVERHEAD_NONULLS(ARR_NDIM(a)))

ARR_DATA_PTR

#define ARR_DATA_PTR

(

a

)

(((char *) (a)) + ARR_DATA_OFFSET(a))

Definition at line 322 of file array.h.

ARR_DIMS

#define ARR_DIMS

(

a

)

((int *) (((char *) (a)) + sizeof(ArrayType)))

Definition at line 294 of file array.h.

ARR_ELEMTYPE

#define ARR_ELEMTYPE

(

a

)

((a)->elemtype)

Definition at line 292 of file array.h.

ARR_HASNULL

#define ARR_HASNULL

(

a

)

((a)->dataoffset != 0)

Definition at line 291 of file array.h.

ARR_LBOUND

#define ARR_LBOUND

(

a

)

Value:

        ((int *) (((char *) (a)) + sizeof(ArrayType) + \
                  sizeof(int) * ARR_NDIM(a)))

Definition at line 296 of file array.h.

ARR_NDIM

#define ARR_NDIM

(

a

)

((a)->ndim)

Definition at line 290 of file array.h.

ARR_NULLBITMAP

#define ARR_NULLBITMAP

(

a

)

Value:

        (ARR_HASNULL(a) ? \
         (bits8 *) (((char *) (a)) + sizeof(ArrayType) + \
                    2 * sizeof(int) * ARR_NDIM(a)) \
         : (bits8 *) NULL)

Definition at line 300 of file array.h.

         : (bits8 *) NULL)

ARR_OVERHEAD_NONULLS

#define ARR_OVERHEAD_NONULLS

(

ndims

)

MAXALIGN(sizeof(ArrayType) + 2 * sizeof(int) * (ndims))

Definition at line 310 of file array.h.

ARR_OVERHEAD_WITHNULLS

#define ARR_OVERHEAD_WITHNULLS	(		ndims,
			nitems
	)

Value:

        MAXALIGN(sizeof(ArrayType) + 2 * sizeof(int) * (ndims) + \
                 ((nitems) + 7) / 8)

Definition at line 312 of file array.h.

ARR_SIZE

#define ARR_SIZE

(

a

)

VARSIZE(a)

Definition at line 289 of file array.h.

DatumGetArrayTypeP

#define DatumGetArrayTypeP

(

X

)

((ArrayType *) PG_DETOAST_DATUM(X))

Definition at line 261 of file array.h.

DatumGetArrayTypePCopy

#define DatumGetArrayTypePCopy

(

X

)

((ArrayType *) PG_DETOAST_DATUM_COPY(X))

Definition at line 262 of file array.h.

EA_MAGIC

#define EA_MAGIC   689375833 /* ID for debugging crosschecks */

Definition at line 113 of file array.h.

MaxArraySize

#define MaxArraySize   ((Size) (MaxAllocSize / sizeof(Datum)))

Definition at line 82 of file array.h.

MAXDIM

#define MAXDIM   6

Definition at line 75 of file array.h.

PG_GETARG_ANY_ARRAY_P

#define PG_GETARG_ANY_ARRAY_P

(

n

)

DatumGetAnyArrayP(PG_GETARG_DATUM(n))

Definition at line 274 of file array.h.

PG_GETARG_ARRAYTYPE_P

#define PG_GETARG_ARRAYTYPE_P

(

n

)

DatumGetArrayTypeP(PG_GETARG_DATUM(n))

Definition at line 263 of file array.h.

PG_GETARG_ARRAYTYPE_P_COPY

#define PG_GETARG_ARRAYTYPE_P_COPY

(

n

)

DatumGetArrayTypePCopy(PG_GETARG_DATUM(n))

Definition at line 264 of file array.h.

PG_GETARG_EXPANDED_ARRAY

#define PG_GETARG_EXPANDED_ARRAY

(

n

)

DatumGetExpandedArray(PG_GETARG_DATUM(n))

Definition at line 268 of file array.h.

PG_GETARG_EXPANDED_ARRAYX

#define PG_GETARG_EXPANDED_ARRAYX	(		n,
			metacache
	)		DatumGetExpandedArrayX(PG_GETARG_DATUM(n), metacache)

Definition at line 269 of file array.h.

PG_RETURN_ARRAYTYPE_P

#define PG_RETURN_ARRAYTYPE_P

(

x

)

PG_RETURN_POINTER(x)

Definition at line 265 of file array.h.

PG_RETURN_EXPANDED_ARRAY

#define PG_RETURN_EXPANDED_ARRAY

(

x

)

PG_RETURN_DATUM(EOHPGetRWDatum(&(x)->hdr))

Definition at line 271 of file array.h.

Typedef Documentation

AnyArrayType

typedef union AnyArrayType AnyArrayType

ArrayBuildState

typedef struct ArrayBuildState ArrayBuildState

ArrayBuildStateAny

typedef struct ArrayBuildStateAny ArrayBuildStateAny

ArrayBuildStateArr

typedef struct ArrayBuildStateArr ArrayBuildStateArr

ArrayIterator

typedef struct ArrayIteratorData* ArrayIterator

Definition at line 258 of file array.h.

ArrayMapState

typedef struct ArrayMapState ArrayMapState

ArrayMetaState

typedef struct ArrayMetaState ArrayMetaState

ArrayType

typedef struct ArrayType ArrayType

ExpandedArrayHeader

typedef struct ExpandedArrayHeader ExpandedArrayHeader

ExprContext

typedef struct ExprContext ExprContext

Definition at line 69 of file array.h.

ExprState

typedef struct ExprState ExprState

Definition at line 68 of file array.h.

Function Documentation

accumArrayResult()

ArrayBuildState * accumArrayResult ( ArrayBuildState *  astate, Datum  dvalue, bool  disnull, Oid  element_type, MemoryContext  rcontext  )

extern

Definition at line 5365 of file arrayfuncs.c.

{
    MemoryContext oldcontext;
 
    if (astate == NULL)
    {
        /* First time through --- initialize */
        astate = initArrayResult(element_type, rcontext, true);
    }
    else
    {
        Assert(astate->element_type == element_type);
    }
 
    oldcontext = MemoryContextSwitchTo(astate->mcontext);
 
    /* enlarge dvalues[]/dnulls[] if needed */
    if (astate->nelems >= astate->alen)
    {
        astate->alen *= 2;
        /* give an array-related error if we go past MaxAllocSize */
        if (!AllocSizeIsValid(astate->alen * sizeof(Datum)))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array size exceeds the maximum allowed (%zu)",
                            MaxAllocSize)));
        astate->dvalues = (Datum *)
            repalloc(astate->dvalues, astate->alen * sizeof(Datum));
        astate->dnulls = (bool *)
            repalloc(astate->dnulls, astate->alen * sizeof(bool));
    }
 
    /*
     * Ensure pass-by-ref stuff is copied into mcontext; and detoast it too if
     * it's varlena.  (You might think that detoasting is not needed here
     * because construct_md_array can detoast the array elements later.
     * However, we must not let construct_md_array modify the ArrayBuildState
     * because that would mean array_agg_finalfn damages its input, which is
     * verboten.  Also, this way frequently saves one copying step.)
     */
    if (!disnull && !astate->typbyval)
    {
        if (astate->typlen == -1)
            dvalue = PointerGetDatum(PG_DETOAST_DATUM_COPY(dvalue));
        else
            dvalue = datumCopy(dvalue, astate->typbyval, astate->typlen);
    }
 
    astate->dvalues[astate->nelems] = dvalue;
    astate->dnulls[astate->nelems] = disnull;
    astate->nelems++;
 
    MemoryContextSwitchTo(oldcontext);
 
    return astate;
}

References ArrayBuildState::alen, AllocSizeIsValid, Assert, datumCopy(), ArrayBuildState::dnulls, ArrayBuildState::dvalues, ArrayBuildState::element_type, ereport, errcode(), errmsg(), ERROR, fb(), initArrayResult(), MaxAllocSize, ArrayBuildState::mcontext, MemoryContextSwitchTo(), ArrayBuildState::nelems, PG_DETOAST_DATUM_COPY, PointerGetDatum(), repalloc(), ArrayBuildState::typbyval, and ArrayBuildState::typlen.

Referenced by accumArrayResultAny(), array_agg_transfn(), array_positions(), array_to_datum_internal(), brin_minmax_multi_summary_out(), daitch_mokotoff_coding(), dblink_get_connections(), find_or_create_child_node(), multirange_agg_transfn(), optionListToArray(), parse_ident(), pg_get_statisticsobjdef_expressions(), pg_stats_ext_mcvlist_items(), PLySequence_ToArray_recurse(), populate_array_element(), range_agg_transfn(), regexp_split_to_array(), serialize_expr_stats(), split_text_accum_result(), transformRelOptions(), and tuple_data_split_internal().

accumArrayResultAny()

ArrayBuildStateAny * accumArrayResultAny ( ArrayBuildStateAny *  astate, Datum  dvalue, bool  disnull, Oid  input_type, MemoryContext  rcontext  )

extern

Definition at line 5844 of file arrayfuncs.c.

{
    if (astate == NULL)
        astate = initArrayResultAny(input_type, rcontext, true);
 
    if (astate->scalarstate)
        (void) accumArrayResult(astate->scalarstate,
                                dvalue, disnull,
                                input_type, rcontext);
    else
        (void) accumArrayResultArr(astate->arraystate,
                                   dvalue, disnull,
                                   input_type, rcontext);
 
    return astate;
}

References accumArrayResult(), accumArrayResultArr(), ArrayBuildStateAny::arraystate, fb(), initArrayResultAny(), and ArrayBuildStateAny::scalarstate.

Referenced by array_sort_internal(), ExecScanSubPlan(), and ExecSetParamPlan().

accumArrayResultArr()

ArrayBuildStateArr * accumArrayResultArr ( ArrayBuildStateArr *  astate, Datum  dvalue, bool  disnull, Oid  array_type, MemoryContext  rcontext  )

extern

Definition at line 5565 of file arrayfuncs.c.

{
    ArrayType  *arg;
    MemoryContext oldcontext;
    int        *dims,
               *lbs,
                ndims,
                nitems,
                ndatabytes;
    char       *data;
    int         i;
 
    /*
     * We disallow accumulating null subarrays.  Another plausible definition
     * is to ignore them, but callers that want that can just skip calling
     * this function.
     */
    if (disnull)
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("cannot accumulate null arrays")));
 
    /* Detoast input array in caller's context */
    arg = DatumGetArrayTypeP(dvalue);
 
    if (astate == NULL)
        astate = initArrayResultArr(array_type, InvalidOid, rcontext, true);
    else
        Assert(astate->array_type == array_type);
 
    oldcontext = MemoryContextSwitchTo(astate->mcontext);
 
    /* Collect this input's dimensions */
    ndims = ARR_NDIM(arg);
    dims = ARR_DIMS(arg);
    lbs = ARR_LBOUND(arg);
    data = ARR_DATA_PTR(arg);
    nitems = ArrayGetNItems(ndims, dims);
    ndatabytes = ARR_SIZE(arg) - ARR_DATA_OFFSET(arg);
 
    if (astate->ndims == 0)
    {
        /* First input; check/save the dimensionality info */
 
        /* Should we allow empty inputs and just produce an empty output? */
        if (ndims == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("cannot accumulate empty arrays")));
        if (ndims + 1 > MAXDIM)
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
                            ndims + 1, MAXDIM)));
 
        /*
         * The output array will have n+1 dimensions, with the ones after the
         * first matching the input's dimensions.
         */
        astate->ndims = ndims + 1;
        astate->dims[0] = 0;
        memcpy(&astate->dims[1], dims, ndims * sizeof(int));
        astate->lbs[0] = 1;
        memcpy(&astate->lbs[1], lbs, ndims * sizeof(int));
 
        /* Allocate at least enough data space for this item */
        astate->abytes = pg_nextpower2_32(Max(1024, ndatabytes + 1));
        astate->data = (char *) palloc(astate->abytes);
    }
    else
    {
        /* Second or later input: must match first input's dimensionality */
        if (astate->ndims != ndims + 1)
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("cannot accumulate arrays of different dimensionality")));
        for (i = 0; i < ndims; i++)
        {
            if (astate->dims[i + 1] != dims[i] || astate->lbs[i + 1] != lbs[i])
                ereport(ERROR,
                        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                         errmsg("cannot accumulate arrays of different dimensionality")));
        }
 
        /* Enlarge data space if needed */
        if (astate->nbytes + ndatabytes > astate->abytes)
        {
            astate->abytes = Max(astate->abytes * 2,
                                 astate->nbytes + ndatabytes);
            astate->data = (char *) repalloc(astate->data, astate->abytes);
        }
    }
 
    /*
     * Copy the data portion of the sub-array.  Note we assume that the
     * advertised data length of the sub-array is properly aligned.  We do not
     * have to worry about detoasting elements since whatever's in the
     * sub-array should be OK already.
     */
    memcpy(astate->data + astate->nbytes, data, ndatabytes);
    astate->nbytes += ndatabytes;
 
    /* Deal with null bitmap if needed */
    if (astate->nullbitmap || ARR_HASNULL(arg))
    {
        int         newnitems = astate->nitems + nitems;
 
        if (astate->nullbitmap == NULL)
        {
            /*
             * First input with nulls; we must retrospectively handle any
             * previous inputs by marking all their items non-null.
             */
            astate->aitems = pg_nextpower2_32(Max(256, newnitems + 1));
            astate->nullbitmap = (bits8 *) palloc((astate->aitems + 7) / 8);
            array_bitmap_copy(astate->nullbitmap, 0,
                              NULL, 0,
                              astate->nitems);
        }
        else if (newnitems > astate->aitems)
        {
            astate->aitems = Max(astate->aitems * 2, newnitems);
            astate->nullbitmap = (bits8 *)
                repalloc(astate->nullbitmap, (astate->aitems + 7) / 8);
        }
        array_bitmap_copy(astate->nullbitmap, astate->nitems,
                          ARR_NULLBITMAP(arg), 0,
                          nitems);
    }
 
    astate->nitems += nitems;
    astate->dims[0] += 1;
 
    MemoryContextSwitchTo(oldcontext);
 
    /* Release detoasted copy if any */
    if (arg != DatumGetPointer(dvalue))
        pfree(arg);
 
    return astate;
}

References ArrayBuildStateArr::abytes, ArrayBuildStateArr::aitems, arg, ARR_DATA_OFFSET, ARR_DATA_PTR, ARR_DIMS, ARR_HASNULL, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ARR_SIZE, array_bitmap_copy(), ArrayBuildStateArr::array_type, ArrayGetNItems(), Assert, ArrayBuildStateArr::data, data, DatumGetArrayTypeP, DatumGetPointer(), ArrayBuildStateArr::dims, ereport, errcode(), errmsg(), ERROR, fb(), i, initArrayResultArr(), InvalidOid, ArrayBuildStateArr::lbs, Max, MAXDIM, ArrayBuildStateArr::mcontext, MemoryContextSwitchTo(), ArrayBuildStateArr::nbytes, ArrayBuildStateArr::ndims, ArrayBuildStateArr::nitems, nitems, ArrayBuildStateArr::nullbitmap, palloc(), pfree(), pg_nextpower2_32(), and repalloc().

Referenced by accumArrayResultAny(), and array_agg_array_transfn().

array_bitmap_copy()

void array_bitmap_copy ( bits8 *  destbitmap, int  destoffset, const bits8 *  srcbitmap, int  srcoffset, int  nitems  )

extern

Definition at line 4980 of file arrayfuncs.c.

{
    int         destbitmask,
                destbitval,
                srcbitmask,
                srcbitval;
 
    Assert(destbitmap);
    if (nitems <= 0)
        return;                 /* don't risk fetch off end of memory */
    destbitmap += destoffset / 8;
    destbitmask = 1 << (destoffset % 8);
    destbitval = *destbitmap;
    if (srcbitmap)
    {
        srcbitmap += srcoffset / 8;
        srcbitmask = 1 << (srcoffset % 8);
        srcbitval = *srcbitmap;
        while (nitems-- > 0)
        {
            if (srcbitval & srcbitmask)
                destbitval |= destbitmask;
            else
                destbitval &= ~destbitmask;
            destbitmask <<= 1;
            if (destbitmask == 0x100)
            {
                *destbitmap++ = destbitval;
                destbitmask = 1;
                if (nitems > 0)
                    destbitval = *destbitmap;
            }
            srcbitmask <<= 1;
            if (srcbitmask == 0x100)
            {
                srcbitmap++;
                srcbitmask = 1;
                if (nitems > 0)
                    srcbitval = *srcbitmap;
            }
        }
        if (destbitmask != 1)
            *destbitmap = destbitval;
    }
    else
    {
        while (nitems-- > 0)
        {
            destbitval |= destbitmask;
            destbitmask <<= 1;
            if (destbitmask == 0x100)
            {
                *destbitmap++ = destbitval;
                destbitmask = 1;
                if (nitems > 0)
                    destbitval = *destbitmap;
            }
        }
        if (destbitmask != 1)
            *destbitmap = destbitval;
    }
}

References Assert, fb(), and nitems.

Referenced by accumArrayResultArr(), array_agg_array_combine(), array_cat(), array_extract_slice(), array_insert_slice(), array_set_element(), array_set_slice(), ExecEvalArrayExpr(), and makeArrayResultArr().

array_contains_nulls()

bool array_contains_nulls ( const ArrayType *  array )

extern

Definition at line 3781 of file arrayfuncs.c.

{
    int         nelems;
    bits8      *bitmap;
    int         bitmask;
 
    /* Easy answer if there's no null bitmap */
    if (!ARR_HASNULL(array))
        return false;
 
    nelems = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
 
    bitmap = ARR_NULLBITMAP(array);
 
    /* check whole bytes of the bitmap byte-at-a-time */
    while (nelems >= 8)
    {
        if (*bitmap != 0xFF)
            return true;
        bitmap++;
        nelems -= 8;
    }
 
    /* check last partial byte */
    bitmask = 1;
    while (nelems > 0)
    {
        if ((*bitmap & bitmask) == 0)
            return true;
        bitmask <<= 1;
        nelems--;
    }
 
    return false;
}

References ARR_DIMS, ARR_HASNULL, ARR_NDIM, ARR_NULLBITMAP, and ArrayGetNItems().

Referenced by _arrq_cons(), _lca(), _lt_q_regex(), _ltree_compress(), array_fill_internal(), array_iterator(), array_position_common(), array_positions(), ArrayGetIntegerTypmods(), arrq_cons(), check_mcvlist_array(), cube_a_f8(), cube_a_f8_f8(), cube_subset(), get_jsonb_path_all(), get_path_all(), getWeights(), lt_q_regex(), pg_isolation_test_session_is_blocked(), pg_logical_slot_get_changes_guts(), sanity_check_array(), sanity_check_tid_array(), statatt_build_stavalues(), stats_check_arg_array(), width_bucket_array(), and worker_spi_launch().

array_create_iterator()

ArrayIterator array_create_iterator ( ArrayType *  arr, int  slice_ndim, ArrayMetaState *  mstate  )

extern

Definition at line 4609 of file arrayfuncs.c.

{
    ArrayIterator iterator = palloc0_object(ArrayIteratorData);
 
    /*
     * Sanity-check inputs --- caller should have got this right already
     */
    Assert(arr);
    if (slice_ndim < 0 || slice_ndim > ARR_NDIM(arr))
        elog(ERROR, "invalid arguments to array_create_iterator");
 
    /*
     * Remember basic info about the array and its element type
     */
    iterator->arr = arr;
    iterator->nullbitmap = ARR_NULLBITMAP(arr);
    iterator->nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
 
    if (mstate != NULL)
    {
        Assert(mstate->element_type == ARR_ELEMTYPE(arr));
 
        iterator->typlen = mstate->typlen;
        iterator->typbyval = mstate->typbyval;
        iterator->typalign = mstate->typalign;
    }
    else
        get_typlenbyvalalign(ARR_ELEMTYPE(arr),
                             &iterator->typlen,
                             &iterator->typbyval,
                             &iterator->typalign);
    iterator->typalignby = typalign_to_alignby(iterator->typalign);
 
    /*
     * Remember the slicing parameters.
     */
    iterator->slice_ndim = slice_ndim;
 
    if (slice_ndim > 0)
    {
        /*
         * Get pointers into the array's dims and lbound arrays to represent
         * the dims/lbound arrays of a slice.  These are the same as the
         * rightmost N dimensions of the array.
         */
        iterator->slice_dims = ARR_DIMS(arr) + ARR_NDIM(arr) - slice_ndim;
        iterator->slice_lbound = ARR_LBOUND(arr) + ARR_NDIM(arr) - slice_ndim;
 
        /*
         * Compute number of elements in a slice.
         */
        iterator->slice_len = ArrayGetNItems(slice_ndim,
                                             iterator->slice_dims);
 
        /*
         * Create workspace for building sub-arrays.
         */
        iterator->slice_values = (Datum *)
            palloc(iterator->slice_len * sizeof(Datum));
        iterator->slice_nulls = (bool *)
            palloc(iterator->slice_len * sizeof(bool));
    }
 
    /*
     * Initialize our data pointer and linear element number.  These will
     * advance through the array during array_iterate().
     */
    iterator->data_ptr = ARR_DATA_PTR(arr);
    iterator->current_item = 0;
 
    return iterator;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), Assert, elog, ERROR, fb(), get_typlenbyvalalign(), palloc(), palloc0_object, and typalign_to_alignby().

Referenced by array_position_common(), array_positions(), array_sort_internal(), and exec_stmt_foreach_a().

array_free_iterator()

void array_free_iterator ( ArrayIterator  iterator )

extern

Definition at line 4772 of file arrayfuncs.c.

{
    if (iterator->slice_ndim > 0)
    {
        pfree(iterator->slice_values);
        pfree(iterator->slice_nulls);
    }
    pfree(iterator);
}

References fb(), and pfree().

Referenced by array_position_common(), array_positions(), and array_sort_internal().

array_get_element()

Datum array_get_element ( Datum  arraydatum, int  nSubscripts, int *  indx, int  arraytyplen, int  elmlen, bool  elmbyval, char  elmalign, bool *  isNull  )

extern

Definition at line 1824 of file arrayfuncs.c.

{
    int         i,
                ndim,
               *dim,
               *lb,
                offset,
                fixedDim[1],
                fixedLb[1];
    char       *arraydataptr,
               *retptr;
    bits8      *arraynullsptr;
 
    if (arraytyplen > 0)
    {
        /*
         * fixed-length arrays -- these are assumed to be 1-d, 0-based
         */
        ndim = 1;
        fixedDim[0] = arraytyplen / elmlen;
        fixedLb[0] = 0;
        dim = fixedDim;
        lb = fixedLb;
        arraydataptr = (char *) DatumGetPointer(arraydatum);
        arraynullsptr = NULL;
    }
    else if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(arraydatum)))
    {
        /* expanded array: let's do this in a separate function */
        return array_get_element_expanded(arraydatum,
                                          nSubscripts,
                                          indx,
                                          arraytyplen,
                                          elmlen,
                                          elmbyval,
                                          elmalign,
                                          isNull);
    }
    else
    {
        /* detoast array if necessary, producing normal varlena input */
        ArrayType  *array = DatumGetArrayTypeP(arraydatum);
 
        ndim = ARR_NDIM(array);
        dim = ARR_DIMS(array);
        lb = ARR_LBOUND(array);
        arraydataptr = ARR_DATA_PTR(array);
        arraynullsptr = ARR_NULLBITMAP(array);
    }
 
    /*
     * Return NULL for invalid subscript
     */
    if (ndim != nSubscripts || ndim <= 0 || ndim > MAXDIM)
    {
        *isNull = true;
        return (Datum) 0;
    }
    for (i = 0; i < ndim; i++)
    {
        if (indx[i] < lb[i] || indx[i] >= (dim[i] + lb[i]))
        {
            *isNull = true;
            return (Datum) 0;
        }
    }
 
    /*
     * Calculate the element number
     */
    offset = ArrayGetOffset(nSubscripts, dim, lb, indx);
 
    /*
     * Check for NULL array element
     */
    if (array_get_isnull(arraynullsptr, offset))
    {
        *isNull = true;
        return (Datum) 0;
    }
 
    /*
     * OK, get the element
     */
    *isNull = false;
    retptr = array_seek(arraydataptr, 0, arraynullsptr, offset,
                        elmlen, elmbyval, elmalign);
    return ArrayCast(retptr, elmbyval, elmlen);
}

References ARR_DATA_PTR, ARR_DIMS, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, array_get_element_expanded(), array_get_isnull(), array_seek(), ArrayCast(), ArrayGetOffset(), DatumGetArrayTypeP, DatumGetPointer(), fb(), i, MAXDIM, and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by array_ref(), array_subscript_fetch(), array_subscript_fetch_old(), ATExecAlterColumnType(), and RelationBuildTupleDesc().

array_get_slice()

Datum array_get_slice ( Datum  arraydatum, int  nSubscripts, int *  upperIndx, int *  lowerIndx, bool *  upperProvided, bool *  lowerProvided, int  arraytyplen, int  elmlen, bool  elmbyval, char  elmalign  )

extern

Definition at line 2034 of file arrayfuncs.c.

{
    ArrayType  *array;
    ArrayType  *newarray;
    int         i,
                ndim,
               *dim,
               *lb,
               *newlb;
    int         fixedDim[1],
                fixedLb[1];
    Oid         elemtype;
    char       *arraydataptr;
    bits8      *arraynullsptr;
    int32       dataoffset;
    int         bytes,
                span[MAXDIM];
 
    if (arraytyplen > 0)
    {
        /*
         * fixed-length arrays -- currently, cannot slice these because parser
         * labels output as being of the fixed-length array type! Code below
         * shows how we could support it if the parser were changed to label
         * output as a suitable varlena array type.
         */
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("slices of fixed-length arrays not implemented")));
 
        /*
         * fixed-length arrays -- these are assumed to be 1-d, 0-based
         *
         * XXX where would we get the correct ELEMTYPE from?
         */
        ndim = 1;
        fixedDim[0] = arraytyplen / elmlen;
        fixedLb[0] = 0;
        dim = fixedDim;
        lb = fixedLb;
        elemtype = InvalidOid;  /* XXX */
        arraydataptr = (char *) DatumGetPointer(arraydatum);
        arraynullsptr = NULL;
    }
    else
    {
        /* detoast input array if necessary */
        array = DatumGetArrayTypeP(arraydatum);
 
        ndim = ARR_NDIM(array);
        dim = ARR_DIMS(array);
        lb = ARR_LBOUND(array);
        elemtype = ARR_ELEMTYPE(array);
        arraydataptr = ARR_DATA_PTR(array);
        arraynullsptr = ARR_NULLBITMAP(array);
    }
 
    /*
     * Check provided subscripts.  A slice exceeding the current array limits
     * is silently truncated to the array limits.  If we end up with an empty
     * slice, return an empty array.
     */
    if (ndim < nSubscripts || ndim <= 0 || ndim > MAXDIM)
        return PointerGetDatum(construct_empty_array(elemtype));
 
    for (i = 0; i < nSubscripts; i++)
    {
        if (!lowerProvided[i] || lowerIndx[i] < lb[i])
            lowerIndx[i] = lb[i];
        if (!upperProvided[i] || upperIndx[i] >= (dim[i] + lb[i]))
            upperIndx[i] = dim[i] + lb[i] - 1;
        if (lowerIndx[i] > upperIndx[i])
            return PointerGetDatum(construct_empty_array(elemtype));
    }
    /* fill any missing subscript positions with full array range */
    for (; i < ndim; i++)
    {
        lowerIndx[i] = lb[i];
        upperIndx[i] = dim[i] + lb[i] - 1;
        if (lowerIndx[i] > upperIndx[i])
            return PointerGetDatum(construct_empty_array(elemtype));
    }
 
    mda_get_range(ndim, span, lowerIndx, upperIndx);
 
    bytes = array_slice_size(arraydataptr, arraynullsptr,
                             ndim, dim, lb,
                             lowerIndx, upperIndx,
                             elmlen, elmbyval, elmalign);
 
    /*
     * Currently, we put a null bitmap in the result if the source has one;
     * could be smarter ...
     */
    if (arraynullsptr)
    {
        dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, ArrayGetNItems(ndim, span));
        bytes += dataoffset;
    }
    else
    {
        dataoffset = 0;         /* marker for no null bitmap */
        bytes += ARR_OVERHEAD_NONULLS(ndim);
    }
 
    newarray = (ArrayType *) palloc0(bytes);
    SET_VARSIZE(newarray, bytes);
    newarray->ndim = ndim;
    newarray->dataoffset = dataoffset;
    newarray->elemtype = elemtype;
    memcpy(ARR_DIMS(newarray), span, ndim * sizeof(int));
 
    /*
     * Lower bounds of the new array are set to 1.  Formerly (before 7.3) we
     * copied the given lowerIndx values ... but that seems confusing.
     */
    newlb = ARR_LBOUND(newarray);
    for (i = 0; i < ndim; i++)
        newlb[i] = 1;
 
    array_extract_slice(newarray,
                        ndim, dim, lb,
                        arraydataptr, arraynullsptr,
                        lowerIndx, upperIndx,
                        elmlen, elmbyval, elmalign);
 
    return PointerGetDatum(newarray);
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, array_extract_slice(), array_slice_size(), ArrayGetNItems(), construct_empty_array(), DatumGetArrayTypeP, DatumGetPointer(), ereport, errcode(), errmsg(), ERROR, fb(), i, InvalidOid, MAXDIM, mda_get_range(), palloc0(), PointerGetDatum(), and SET_VARSIZE().

Referenced by array_subscript_fetch_old_slice(), array_subscript_fetch_slice(), and trim_array().

array_iterate()

bool array_iterate ( ArrayIterator  iterator, Datum *  value, bool *  isnull  )

extern

Definition at line 4689 of file arrayfuncs.c.

{
    /* Done if we have reached the end of the array */
    if (iterator->current_item >= iterator->nitems)
        return false;
 
    if (iterator->slice_ndim == 0)
    {
        /*
         * Scalar case: return one element.
         */
        if (array_get_isnull(iterator->nullbitmap, iterator->current_item++))
        {
            *isnull = true;
            *value = (Datum) 0;
        }
        else
        {
            /* non-NULL, so fetch the individual Datum to return */
            char       *p = iterator->data_ptr;
 
            *isnull = false;
            *value = fetch_att(p, iterator->typbyval, iterator->typlen);
 
            /* Move our data pointer forward to the next element */
            p = att_addlength_pointer(p, iterator->typlen, p);
            p = (char *) att_nominal_alignby(p, iterator->typalignby);
            iterator->data_ptr = p;
        }
    }
    else
    {
        /*
         * Slice case: build and return an array of the requested size.
         */
        ArrayType  *result;
        Datum      *values = iterator->slice_values;
        bool       *nulls = iterator->slice_nulls;
        char       *p = iterator->data_ptr;
        int         i;
 
        for (i = 0; i < iterator->slice_len; i++)
        {
            if (array_get_isnull(iterator->nullbitmap,
                                 iterator->current_item++))
            {
                nulls[i] = true;
                values[i] = (Datum) 0;
            }
            else
            {
                nulls[i] = false;
                values[i] = fetch_att(p, iterator->typbyval, iterator->typlen);
 
                /* Move our data pointer forward to the next element */
                p = att_addlength_pointer(p, iterator->typlen, p);
                p = (char *) att_nominal_alignby(p, iterator->typalignby);
            }
        }
 
        iterator->data_ptr = p;
 
        result = construct_md_array(values,
                                    nulls,
                                    iterator->slice_ndim,
                                    iterator->slice_dims,
                                    iterator->slice_lbound,
                                    ARR_ELEMTYPE(iterator->arr),
                                    iterator->typlen,
                                    iterator->typbyval,
                                    iterator->typalign);
 
        *isnull = false;
        *value = PointerGetDatum(result);
    }
 
    return true;
}

References ARR_ELEMTYPE, array_get_isnull(), att_addlength_pointer, att_nominal_alignby, construct_md_array(), fb(), fetch_att(), i, PointerGetDatum(), value, and values.

Referenced by array_position_common(), array_positions(), array_sort_internal(), and exec_stmt_foreach_a().

array_map()

Datum array_map ( Datum  arrayd, ExprState *  exprstate, ExprContext *  econtext, Oid  retType, ArrayMapState *  amstate  )

extern

Definition at line 3206 of file arrayfuncs.c.

{
    AnyArrayType *v = DatumGetAnyArrayP(arrayd);
    ArrayType  *result;
    Datum      *values;
    bool       *nulls;
    int        *dim;
    int         ndim;
    int         nitems;
    int         i;
    int32       nbytes = 0;
    int32       dataoffset;
    bool        hasnulls;
    Oid         inpType;
    int         inp_typlen;
    bool        inp_typbyval;
    char        inp_typalign;
    int         typlen;
    bool        typbyval;
    char        typalign;
    uint8       typalignby;
    array_iter  iter;
    ArrayMetaState *inp_extra;
    ArrayMetaState *ret_extra;
    Datum      *transform_source = exprstate->innermost_caseval;
    bool       *transform_source_isnull = exprstate->innermost_casenull;
 
    inpType = AARR_ELEMTYPE(v);
    ndim = AARR_NDIM(v);
    dim = AARR_DIMS(v);
    nitems = ArrayGetNItems(ndim, dim);
 
    /* Check for empty array */
    if (nitems <= 0)
    {
        /* Return empty array */
        return PointerGetDatum(construct_empty_array(retType));
    }
 
    /*
     * We arrange to look up info about input and return element types only
     * once per series of calls, assuming the element type doesn't change
     * underneath us.
     */
    inp_extra = &amstate->inp_extra;
    ret_extra = &amstate->ret_extra;
 
    if (inp_extra->element_type != inpType)
    {
        get_typlenbyvalalign(inpType,
                             &inp_extra->typlen,
                             &inp_extra->typbyval,
                             &inp_extra->typalign);
        inp_extra->element_type = inpType;
    }
    inp_typlen = inp_extra->typlen;
    inp_typbyval = inp_extra->typbyval;
    inp_typalign = inp_extra->typalign;
 
    if (ret_extra->element_type != retType)
    {
        get_typlenbyvalalign(retType,
                             &ret_extra->typlen,
                             &ret_extra->typbyval,
                             &ret_extra->typalign);
        ret_extra->element_type = retType;
    }
    typlen = ret_extra->typlen;
    typbyval = ret_extra->typbyval;
    typalign = ret_extra->typalign;
    typalignby = typalign_to_alignby(typalign);
 
    /* Allocate temporary arrays for new values */
    values = (Datum *) palloc(nitems * sizeof(Datum));
    nulls = (bool *) palloc(nitems * sizeof(bool));
 
    /* Loop over source data */
    array_iter_setup(&iter, v, inp_typlen, inp_typbyval, inp_typalign);
    hasnulls = false;
 
    for (i = 0; i < nitems; i++)
    {
        /* Get source element, checking for NULL */
        *transform_source =
            array_iter_next(&iter, transform_source_isnull, i);
 
        /* Apply the given expression to source element */
        values[i] = ExecEvalExpr(exprstate, econtext, &nulls[i]);
 
        if (nulls[i])
            hasnulls = true;
        else
        {
            /* Ensure data is not toasted */
            if (typlen == -1)
                values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
            /* Update total result size */
            nbytes = att_addlength_datum(nbytes, typlen, values[i]);
            nbytes = att_nominal_alignby(nbytes, typalignby);
            /* check for overflow of total request */
            if (!AllocSizeIsValid(nbytes))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%zu)",
                                MaxAllocSize)));
        }
    }
 
    /* Allocate and fill the result array */
    if (hasnulls)
    {
        dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
        nbytes += dataoffset;
    }
    else
    {
        dataoffset = 0;         /* marker for no null bitmap */
        nbytes += ARR_OVERHEAD_NONULLS(ndim);
    }
    result = (ArrayType *) palloc0(nbytes);
    SET_VARSIZE(result, nbytes);
    result->ndim = ndim;
    result->dataoffset = dataoffset;
    result->elemtype = retType;
    memcpy(ARR_DIMS(result), AARR_DIMS(v), ndim * sizeof(int));
    memcpy(ARR_LBOUND(result), AARR_LBOUND(v), ndim * sizeof(int));
 
    CopyArrayEls(result,
                 values, nulls, nitems,
                 typlen, typbyval, typalign,
                 false);
 
    /*
     * Note: do not risk trying to pfree the results of the called expression
     */
    pfree(values);
    pfree(nulls);
 
    return PointerGetDatum(result);
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_LBOUND, AARR_NDIM, AllocSizeIsValid, ARR_DIMS, ARR_LBOUND, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, array_iter_next(), array_iter_setup(), ArrayGetNItems(), att_addlength_datum, att_nominal_alignby, construct_empty_array(), CopyArrayEls(), ArrayType::dataoffset, DatumGetAnyArrayP(), ArrayMetaState::element_type, ArrayType::elemtype, ereport, errcode(), errmsg(), ERROR, ExecEvalExpr(), fb(), get_typlenbyvalalign(), i, ExprState::innermost_casenull, ExprState::innermost_caseval, ArrayMapState::inp_extra, MaxAllocSize, ArrayType::ndim, nitems, palloc(), palloc0(), pfree(), PG_DETOAST_DATUM, PointerGetDatum(), ArrayMapState::ret_extra, SET_VARSIZE(), typalign, ArrayMetaState::typalign, typalign_to_alignby(), ArrayMetaState::typbyval, ArrayMetaState::typlen, and values.

Referenced by ExecEvalArrayCoerce().

array_ref()

Datum array_ref ( ArrayType *  array, int  nSubscripts, int *  indx, int  arraytyplen, int  elmlen, bool  elmbyval, char  elmalign, bool *  isNull  )

extern

Definition at line 3151 of file arrayfuncs.c.

{
    return array_get_element(PointerGetDatum(array), nSubscripts, indx,
                             arraytyplen, elmlen, elmbyval, elmalign,
                             isNull);
}

References array_get_element(), fb(), and PointerGetDatum().

Referenced by GUCArrayAdd(), GUCArrayDelete(), GUCArrayReset(), pg_get_functiondef(), and TransformGUCArray().

array_set()

ArrayType * array_set ( ArrayType *  array, int  nSubscripts, int *  indx, Datum  dataValue, bool  isNull, int  arraytyplen, int  elmlen, bool  elmbyval, char  elmalign  )

extern

Definition at line 3168 of file arrayfuncs.c.

{
    return DatumGetArrayTypeP(array_set_element(PointerGetDatum(array),
                                                nSubscripts, indx,
                                                dataValue, isNull,
                                                arraytyplen,
                                                elmlen, elmbyval, elmalign));
}

References array_set_element(), DatumGetArrayTypeP, fb(), and PointerGetDatum().

Referenced by GUCArrayAdd(), GUCArrayDelete(), GUCArrayReset(), and pg_extension_config_dump().

array_set_element()

Datum array_set_element ( Datum  arraydatum, int  nSubscripts, int *  indx, Datum  dataValue, bool  isNull, int  arraytyplen, int  elmlen, bool  elmbyval, char  elmalign  )

extern

Definition at line 2205 of file arrayfuncs.c.

{
    ArrayType  *array;
    ArrayType  *newarray;
    int         i,
                ndim,
                dim[MAXDIM],
                lb[MAXDIM],
                offset;
    char       *elt_ptr;
    bool        newhasnulls;
    bits8      *oldnullbitmap;
    int         oldnitems,
                newnitems,
                olddatasize,
                newsize,
                olditemlen,
                newitemlen,
                overheadlen,
                oldoverheadlen,
                addedbefore,
                addedafter,
                lenbefore,
                lenafter;
    uint8       elmalignby = typalign_to_alignby(elmalign);
 
    if (arraytyplen > 0)
    {
        /*
         * fixed-length arrays -- these are assumed to be 1-d, 0-based. We
         * cannot extend them, either.
         */
        char       *resultarray;
 
        if (nSubscripts != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("wrong number of array subscripts")));
 
        if (indx[0] < 0 || indx[0] >= arraytyplen / elmlen)
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("array subscript out of range")));
 
        if (isNull)
            ereport(ERROR,
                    (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                     errmsg("cannot assign null value to an element of a fixed-length array")));
 
        resultarray = (char *) palloc(arraytyplen);
        memcpy(resultarray, DatumGetPointer(arraydatum), arraytyplen);
        elt_ptr = resultarray + indx[0] * elmlen;
        ArrayCastAndSet(dataValue, elmlen, elmbyval, elmalignby, elt_ptr);
        return PointerGetDatum(resultarray);
    }
 
    if (nSubscripts <= 0 || nSubscripts > MAXDIM)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("wrong number of array subscripts")));
 
    /* make sure item to be inserted is not toasted */
    if (elmlen == -1 && !isNull)
        dataValue = PointerGetDatum(PG_DETOAST_DATUM(dataValue));
 
    if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(arraydatum)))
    {
        /* expanded array: let's do this in a separate function */
        return array_set_element_expanded(arraydatum,
                                          nSubscripts,
                                          indx,
                                          dataValue,
                                          isNull,
                                          arraytyplen,
                                          elmlen,
                                          elmbyval,
                                          elmalign);
    }
 
    /* detoast input array if necessary */
    array = DatumGetArrayTypeP(arraydatum);
 
    ndim = ARR_NDIM(array);
 
    /*
     * if number of dims is zero, i.e. an empty array, create an array with
     * nSubscripts dimensions, and set the lower bounds to the supplied
     * subscripts
     */
    if (ndim == 0)
    {
        Oid         elmtype = ARR_ELEMTYPE(array);
 
        for (i = 0; i < nSubscripts; i++)
        {
            dim[i] = 1;
            lb[i] = indx[i];
        }
 
        return PointerGetDatum(construct_md_array(&dataValue, &isNull,
                                                  nSubscripts, dim, lb,
                                                  elmtype,
                                                  elmlen, elmbyval, elmalign));
    }
 
    if (ndim != nSubscripts)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("wrong number of array subscripts")));
 
    /* copy dim/lb since we may modify them */
    memcpy(dim, ARR_DIMS(array), ndim * sizeof(int));
    memcpy(lb, ARR_LBOUND(array), ndim * sizeof(int));
 
    newhasnulls = (ARR_HASNULL(array) || isNull);
    addedbefore = addedafter = 0;
 
    /*
     * Check subscripts.  We assume the existing subscripts passed
     * ArrayCheckBounds, so that dim[i] + lb[i] can be computed without
     * overflow.  But we must beware of other overflows in our calculations of
     * new dim[] values.
     */
    if (ndim == 1)
    {
        if (indx[0] < lb[0])
        {
            /* addedbefore = lb[0] - indx[0]; */
            /* dim[0] += addedbefore; */
            if (pg_sub_s32_overflow(lb[0], indx[0], &addedbefore) ||
                pg_add_s32_overflow(dim[0], addedbefore, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%zu)",
                                MaxArraySize)));
            lb[0] = indx[0];
            if (addedbefore > 1)
                newhasnulls = true; /* will insert nulls */
        }
        if (indx[0] >= (dim[0] + lb[0]))
        {
            /* addedafter = indx[0] - (dim[0] + lb[0]) + 1; */
            /* dim[0] += addedafter; */
            if (pg_sub_s32_overflow(indx[0], dim[0] + lb[0], &addedafter) ||
                pg_add_s32_overflow(addedafter, 1, &addedafter) ||
                pg_add_s32_overflow(dim[0], addedafter, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%zu)",
                                MaxArraySize)));
            if (addedafter > 1)
                newhasnulls = true; /* will insert nulls */
        }
    }
    else
    {
        /*
         * XXX currently we do not support extending multi-dimensional arrays
         * during assignment
         */
        for (i = 0; i < ndim; i++)
        {
            if (indx[i] < lb[i] ||
                indx[i] >= (dim[i] + lb[i]))
                ereport(ERROR,
                        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                         errmsg("array subscript out of range")));
        }
    }
 
    /* This checks for overflow of the array dimensions */
    newnitems = ArrayGetNItems(ndim, dim);
    ArrayCheckBounds(ndim, dim, lb);
 
    /*
     * Compute sizes of items and areas to copy
     */
    if (newhasnulls)
        overheadlen = ARR_OVERHEAD_WITHNULLS(ndim, newnitems);
    else
        overheadlen = ARR_OVERHEAD_NONULLS(ndim);
    oldnitems = ArrayGetNItems(ndim, ARR_DIMS(array));
    oldnullbitmap = ARR_NULLBITMAP(array);
    oldoverheadlen = ARR_DATA_OFFSET(array);
    olddatasize = ARR_SIZE(array) - oldoverheadlen;
    if (addedbefore)
    {
        offset = 0;
        lenbefore = 0;
        olditemlen = 0;
        lenafter = olddatasize;
    }
    else if (addedafter)
    {
        offset = oldnitems;
        lenbefore = olddatasize;
        olditemlen = 0;
        lenafter = 0;
    }
    else
    {
        offset = ArrayGetOffset(nSubscripts, dim, lb, indx);
        elt_ptr = array_seek(ARR_DATA_PTR(array), 0, oldnullbitmap, offset,
                             elmlen, elmbyval, elmalign);
        lenbefore = (int) (elt_ptr - ARR_DATA_PTR(array));
        if (array_get_isnull(oldnullbitmap, offset))
            olditemlen = 0;
        else
        {
            olditemlen = att_addlength_pointer(0, elmlen, elt_ptr);
            olditemlen = att_nominal_alignby(olditemlen, elmalignby);
        }
        lenafter = olddatasize - lenbefore - olditemlen;
    }
 
    if (isNull)
        newitemlen = 0;
    else
    {
        newitemlen = att_addlength_datum(0, elmlen, dataValue);
        newitemlen = att_nominal_alignby(newitemlen, elmalignby);
    }
 
    newsize = overheadlen + lenbefore + newitemlen + lenafter;
 
    /*
     * OK, create the new array and fill in header/dimensions
     */
    newarray = (ArrayType *) palloc0(newsize);
    SET_VARSIZE(newarray, newsize);
    newarray->ndim = ndim;
    newarray->dataoffset = newhasnulls ? overheadlen : 0;
    newarray->elemtype = ARR_ELEMTYPE(array);
    memcpy(ARR_DIMS(newarray), dim, ndim * sizeof(int));
    memcpy(ARR_LBOUND(newarray), lb, ndim * sizeof(int));
 
    /*
     * Fill in data
     */
    memcpy((char *) newarray + overheadlen,
           (char *) array + oldoverheadlen,
           lenbefore);
    if (!isNull)
        ArrayCastAndSet(dataValue, elmlen, elmbyval, elmalignby,
                        (char *) newarray + overheadlen + lenbefore);
    memcpy((char *) newarray + overheadlen + lenbefore + newitemlen,
           (char *) array + oldoverheadlen + lenbefore + olditemlen,
           lenafter);
 
    /*
     * Fill in nulls bitmap if needed
     *
     * Note: it's possible we just replaced the last NULL with a non-NULL, and
     * could get rid of the bitmap.  Seems not worth testing for though.
     */
    if (newhasnulls)
    {
        bits8      *newnullbitmap = ARR_NULLBITMAP(newarray);
 
        /* palloc0 above already marked any inserted positions as nulls */
        /* Fix the inserted value */
        if (addedafter)
            array_set_isnull(newnullbitmap, newnitems - 1, isNull);
        else
            array_set_isnull(newnullbitmap, offset, isNull);
        /* Fix the copied range(s) */
        if (addedbefore)
            array_bitmap_copy(newnullbitmap, addedbefore,
                              oldnullbitmap, 0,
                              oldnitems);
        else
        {
            array_bitmap_copy(newnullbitmap, 0,
                              oldnullbitmap, 0,
                              offset);
            if (addedafter == 0)
                array_bitmap_copy(newnullbitmap, offset + 1,
                                  oldnullbitmap, offset + 1,
                                  oldnitems - offset - 1);
        }
    }
 
    return PointerGetDatum(newarray);
}

References ARR_DATA_OFFSET, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ARR_SIZE, array_bitmap_copy(), array_get_isnull(), array_seek(), array_set_element_expanded(), array_set_isnull(), ArrayCastAndSet(), ArrayCheckBounds(), ArrayGetNItems(), ArrayGetOffset(), att_addlength_datum, att_addlength_pointer, att_nominal_alignby, construct_md_array(), DatumGetArrayTypeP, DatumGetPointer(), ereport, errcode(), errmsg(), ERROR, fb(), i, MaxArraySize, MAXDIM, palloc(), palloc0(), pg_add_s32_overflow(), PG_DETOAST_DATUM, pg_sub_s32_overflow(), PointerGetDatum(), SET_VARSIZE(), typalign_to_alignby(), and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by array_append(), array_prepend(), array_set(), and array_subscript_assign().

array_set_slice()

Datum array_set_slice ( Datum  arraydatum, int  nSubscripts, int *  upperIndx, int *  lowerIndx, bool *  upperProvided, bool *  lowerProvided, Datum  srcArrayDatum, bool  isNull, int  arraytyplen, int  elmlen, bool  elmbyval, char  elmalign  )

extern

Definition at line 2811 of file arrayfuncs.c.

{
    ArrayType  *array;
    ArrayType  *srcArray;
    ArrayType  *newarray;
    int         i,
                ndim,
                dim[MAXDIM],
                lb[MAXDIM],
                span[MAXDIM];
    bool        newhasnulls;
    int         nitems,
                nsrcitems,
                olddatasize,
                newsize,
                olditemsize,
                newitemsize,
                overheadlen,
                oldoverheadlen,
                addedbefore,
                addedafter,
                lenbefore,
                lenafter,
                itemsbefore,
                itemsafter,
                nolditems;
 
    /* Currently, assignment from a NULL source array is a no-op */
    if (isNull)
        return arraydatum;
 
    if (arraytyplen > 0)
    {
        /*
         * fixed-length arrays -- not got round to doing this...
         */
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("updates on slices of fixed-length arrays not implemented")));
    }
 
    /* detoast arrays if necessary */
    array = DatumGetArrayTypeP(arraydatum);
    srcArray = DatumGetArrayTypeP(srcArrayDatum);
 
    /* note: we assume srcArray contains no toasted elements */
 
    ndim = ARR_NDIM(array);
 
    /*
     * if number of dims is zero, i.e. an empty array, create an array with
     * nSubscripts dimensions, and set the upper and lower bounds to the
     * supplied subscripts
     */
    if (ndim == 0)
    {
        Datum      *dvalues;
        bool       *dnulls;
        int         nelems;
        Oid         elmtype = ARR_ELEMTYPE(array);
 
        deconstruct_array(srcArray, elmtype, elmlen, elmbyval, elmalign,
                          &dvalues, &dnulls, &nelems);
 
        for (i = 0; i < nSubscripts; i++)
        {
            if (!upperProvided[i] || !lowerProvided[i])
                ereport(ERROR,
                        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                         errmsg("array slice subscript must provide both boundaries"),
                         errdetail("When assigning to a slice of an empty array value,"
                                   " slice boundaries must be fully specified.")));
 
            /* compute "upperIndx[i] - lowerIndx[i] + 1", detecting overflow */
            if (pg_sub_s32_overflow(upperIndx[i], lowerIndx[i], &dim[i]) ||
                pg_add_s32_overflow(dim[i], 1, &dim[i]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%zu)",
                                MaxArraySize)));
 
            lb[i] = lowerIndx[i];
        }
 
        /* complain if too few source items; we ignore extras, however */
        if (nelems < ArrayGetNItems(nSubscripts, dim))
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("source array too small")));
 
        return PointerGetDatum(construct_md_array(dvalues, dnulls, nSubscripts,
                                                  dim, lb, elmtype,
                                                  elmlen, elmbyval, elmalign));
    }
 
    if (ndim < nSubscripts || ndim <= 0 || ndim > MAXDIM)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("wrong number of array subscripts")));
 
    /* copy dim/lb since we may modify them */
    memcpy(dim, ARR_DIMS(array), ndim * sizeof(int));
    memcpy(lb, ARR_LBOUND(array), ndim * sizeof(int));
 
    newhasnulls = (ARR_HASNULL(array) || ARR_HASNULL(srcArray));
    addedbefore = addedafter = 0;
 
    /*
     * Check subscripts.  We assume the existing subscripts passed
     * ArrayCheckBounds, so that dim[i] + lb[i] can be computed without
     * overflow.  But we must beware of other overflows in our calculations of
     * new dim[] values.
     */
    if (ndim == 1)
    {
        Assert(nSubscripts == 1);
        if (!lowerProvided[0])
            lowerIndx[0] = lb[0];
        if (!upperProvided[0])
            upperIndx[0] = dim[0] + lb[0] - 1;
        if (lowerIndx[0] > upperIndx[0])
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("upper bound cannot be less than lower bound")));
        if (lowerIndx[0] < lb[0])
        {
            /* addedbefore = lb[0] - lowerIndx[0]; */
            /* dim[0] += addedbefore; */
            if (pg_sub_s32_overflow(lb[0], lowerIndx[0], &addedbefore) ||
                pg_add_s32_overflow(dim[0], addedbefore, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%zu)",
                                MaxArraySize)));
            lb[0] = lowerIndx[0];
            if (addedbefore > 1)
                newhasnulls = true; /* will insert nulls */
        }
        if (upperIndx[0] >= (dim[0] + lb[0]))
        {
            /* addedafter = upperIndx[0] - (dim[0] + lb[0]) + 1; */
            /* dim[0] += addedafter; */
            if (pg_sub_s32_overflow(upperIndx[0], dim[0] + lb[0], &addedafter) ||
                pg_add_s32_overflow(addedafter, 1, &addedafter) ||
                pg_add_s32_overflow(dim[0], addedafter, &dim[0]))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%zu)",
                                MaxArraySize)));
            if (addedafter > 1)
                newhasnulls = true; /* will insert nulls */
        }
    }
    else
    {
        /*
         * XXX currently we do not support extending multi-dimensional arrays
         * during assignment
         */
        for (i = 0; i < nSubscripts; i++)
        {
            if (!lowerProvided[i])
                lowerIndx[i] = lb[i];
            if (!upperProvided[i])
                upperIndx[i] = dim[i] + lb[i] - 1;
            if (lowerIndx[i] > upperIndx[i])
                ereport(ERROR,
                        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                         errmsg("upper bound cannot be less than lower bound")));
            if (lowerIndx[i] < lb[i] ||
                upperIndx[i] >= (dim[i] + lb[i]))
                ereport(ERROR,
                        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                         errmsg("array subscript out of range")));
        }
        /* fill any missing subscript positions with full array range */
        for (; i < ndim; i++)
        {
            lowerIndx[i] = lb[i];
            upperIndx[i] = dim[i] + lb[i] - 1;
            if (lowerIndx[i] > upperIndx[i])
                ereport(ERROR,
                        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                         errmsg("upper bound cannot be less than lower bound")));
        }
    }
 
    /* Do this mainly to check for overflow */
    nitems = ArrayGetNItems(ndim, dim);
    ArrayCheckBounds(ndim, dim, lb);
 
    /*
     * Make sure source array has enough entries.  Note we ignore the shape of
     * the source array and just read entries serially.
     */
    mda_get_range(ndim, span, lowerIndx, upperIndx);
    nsrcitems = ArrayGetNItems(ndim, span);
    if (nsrcitems > ArrayGetNItems(ARR_NDIM(srcArray), ARR_DIMS(srcArray)))
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("source array too small")));
 
    /*
     * Compute space occupied by new entries, space occupied by replaced
     * entries, and required space for new array.
     */
    if (newhasnulls)
        overheadlen = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
    else
        overheadlen = ARR_OVERHEAD_NONULLS(ndim);
    newitemsize = array_nelems_size(ARR_DATA_PTR(srcArray), 0,
                                    ARR_NULLBITMAP(srcArray), nsrcitems,
                                    elmlen, elmbyval, elmalign);
    oldoverheadlen = ARR_DATA_OFFSET(array);
    olddatasize = ARR_SIZE(array) - oldoverheadlen;
    if (ndim > 1)
    {
        /*
         * here we do not need to cope with extension of the array; it would
         * be a lot more complicated if we had to do so...
         */
        olditemsize = array_slice_size(ARR_DATA_PTR(array),
                                       ARR_NULLBITMAP(array),
                                       ndim, dim, lb,
                                       lowerIndx, upperIndx,
                                       elmlen, elmbyval, elmalign);
        lenbefore = lenafter = 0;   /* keep compiler quiet */
        itemsbefore = itemsafter = nolditems = 0;
    }
    else
    {
        /*
         * here we must allow for possibility of slice larger than orig array
         * and/or not adjacent to orig array subscripts
         */
        int         oldlb = ARR_LBOUND(array)[0];
        int         oldub = oldlb + ARR_DIMS(array)[0] - 1;
        int         slicelb = Max(oldlb, lowerIndx[0]);
        int         sliceub = Min(oldub, upperIndx[0]);
        char       *oldarraydata = ARR_DATA_PTR(array);
        bits8      *oldarraybitmap = ARR_NULLBITMAP(array);
 
        /* count/size of old array entries that will go before the slice */
        itemsbefore = Min(slicelb, oldub + 1) - oldlb;
        lenbefore = array_nelems_size(oldarraydata, 0, oldarraybitmap,
                                      itemsbefore,
                                      elmlen, elmbyval, elmalign);
        /* count/size of old array entries that will be replaced by slice */
        if (slicelb > sliceub)
        {
            nolditems = 0;
            olditemsize = 0;
        }
        else
        {
            nolditems = sliceub - slicelb + 1;
            olditemsize = array_nelems_size(oldarraydata + lenbefore,
                                            itemsbefore, oldarraybitmap,
                                            nolditems,
                                            elmlen, elmbyval, elmalign);
        }
        /* count/size of old array entries that will go after the slice */
        itemsafter = oldub + 1 - Max(sliceub + 1, oldlb);
        lenafter = olddatasize - lenbefore - olditemsize;
    }
 
    newsize = overheadlen + olddatasize - olditemsize + newitemsize;
 
    newarray = (ArrayType *) palloc0(newsize);
    SET_VARSIZE(newarray, newsize);
    newarray->ndim = ndim;
    newarray->dataoffset = newhasnulls ? overheadlen : 0;
    newarray->elemtype = ARR_ELEMTYPE(array);
    memcpy(ARR_DIMS(newarray), dim, ndim * sizeof(int));
    memcpy(ARR_LBOUND(newarray), lb, ndim * sizeof(int));
 
    if (ndim > 1)
    {
        /*
         * here we do not need to cope with extension of the array; it would
         * be a lot more complicated if we had to do so...
         */
        array_insert_slice(newarray, array, srcArray,
                           ndim, dim, lb,
                           lowerIndx, upperIndx,
                           elmlen, elmbyval, elmalign);
    }
    else
    {
        /* fill in data */
        memcpy((char *) newarray + overheadlen,
               (char *) array + oldoverheadlen,
               lenbefore);
        memcpy((char *) newarray + overheadlen + lenbefore,
               ARR_DATA_PTR(srcArray),
               newitemsize);
        memcpy((char *) newarray + overheadlen + lenbefore + newitemsize,
               (char *) array + oldoverheadlen + lenbefore + olditemsize,
               lenafter);
        /* fill in nulls bitmap if needed */
        if (newhasnulls)
        {
            bits8      *newnullbitmap = ARR_NULLBITMAP(newarray);
            bits8      *oldnullbitmap = ARR_NULLBITMAP(array);
 
            /* palloc0 above already marked any inserted positions as nulls */
            array_bitmap_copy(newnullbitmap, addedbefore,
                              oldnullbitmap, 0,
                              itemsbefore);
            array_bitmap_copy(newnullbitmap, lowerIndx[0] - lb[0],
                              ARR_NULLBITMAP(srcArray), 0,
                              nsrcitems);
            array_bitmap_copy(newnullbitmap, addedbefore + itemsbefore + nolditems,
                              oldnullbitmap, itemsbefore + nolditems,
                              itemsafter);
        }
    }
 
    return PointerGetDatum(newarray);
}

References ARR_DATA_OFFSET, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ARR_SIZE, array_bitmap_copy(), array_insert_slice(), array_nelems_size(), array_slice_size(), ArrayCheckBounds(), ArrayGetNItems(), Assert, construct_md_array(), DatumGetArrayTypeP, deconstruct_array(), ereport, errcode(), errdetail(), errmsg(), ERROR, fb(), i, Max, MaxArraySize, MAXDIM, mda_get_range(), Min, nitems, palloc0(), pg_add_s32_overflow(), pg_sub_s32_overflow(), PointerGetDatum(), and SET_VARSIZE().

Referenced by array_subscript_assign_slice().

ArrayCheckBounds()

void ArrayCheckBounds ( int  ndim, const int *  dims, const int *  lb  )

extern

Definition at line 117 of file arrayutils.c.

{
    (void) ArrayCheckBoundsSafe(ndim, dims, lb, NULL);
}

References ArrayCheckBoundsSafe(), and fb().

Referenced by array_cat(), array_fill_internal(), array_recv(), array_set_element(), array_set_element_expanded(), array_set_slice(), construct_md_array(), ExecEvalArrayExpr(), and makeArrayResultArr().

ArrayCheckBoundsSafe()

bool ArrayCheckBoundsSafe ( int  ndim, const int *  dims, const int *  lb, struct Node *  escontext  )

extern

Definition at line 127 of file arrayutils.c.

{
    int         i;
 
    for (i = 0; i < ndim; i++)
    {
        /* PG_USED_FOR_ASSERTS_ONLY prevents variable-isn't-read warnings */
        int32       sum PG_USED_FOR_ASSERTS_ONLY;
 
        if (pg_add_s32_overflow(dims[i], lb[i], &sum))
            ereturn(escontext, false,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array lower bound is too large: %d",
                            lb[i])));
    }
 
    return true;
}

References ereturn, errcode(), errmsg(), fb(), i, pg_add_s32_overflow(), and PG_USED_FOR_ASSERTS_ONLY.

Referenced by ArrayCheckBounds().

ArrayGetIntegerTypmods()

int32 * ArrayGetIntegerTypmods ( ArrayType *  arr, int *  n  )

extern

Definition at line 233 of file arrayutils.c.

{
    int32      *result;
    Datum      *elem_values;
    int         i;
 
    if (ARR_ELEMTYPE(arr) != CSTRINGOID)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_ELEMENT_ERROR),
                 errmsg("typmod array must be type cstring[]")));
 
    if (ARR_NDIM(arr) != 1)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("typmod array must be one-dimensional")));
 
    if (array_contains_nulls(arr))
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("typmod array must not contain nulls")));
 
    deconstruct_array_builtin(arr, CSTRINGOID, &elem_values, NULL, n);
 
    result = (int32 *) palloc(*n * sizeof(int32));
 
    for (i = 0; i < *n; i++)
        result[i] = pg_strtoint32(DatumGetCString(elem_values[i]));
 
    pfree(elem_values);
 
    return result;
}

References ARR_ELEMTYPE, ARR_NDIM, array_contains_nulls(), DatumGetCString(), deconstruct_array_builtin(), ereport, errcode(), errmsg(), ERROR, fb(), i, palloc(), pfree(), and pg_strtoint32().

Referenced by anybit_typmodin(), anychar_typmodin(), anytime_typmodin(), anytimestamp_typmodin(), intervaltypmodin(), and numerictypmodin().

ArrayGetNItems()

int ArrayGetNItems ( int  ndim, const int *  dims  )

extern

Definition at line 57 of file arrayutils.c.

{
    return ArrayGetNItemsSafe(ndim, dims, NULL);
}

References ArrayGetNItemsSafe(), and fb().

Referenced by _arrq_cons(), _lca(), _lt_q_regex(), _ltree_compress(), accumArrayResultArr(), array_cardinality(), array_cat(), array_cmp(), array_contain_compare(), array_contains_nulls(), array_create_iterator(), array_eq(), array_fill_internal(), array_get_slice(), array_insert_slice(), array_iterator(), array_map(), array_out(), array_recv(), array_replace_internal(), array_send(), array_set_element(), array_set_element_expanded(), array_set_slice(), array_slice_size(), array_to_json_internal(), array_to_jsonb_internal(), array_to_text_internal(), array_unnest(), arrq_cons(), clause_is_strict_for(), construct_md_array(), convert_saop_to_hashed_saop_walker(), count_nulls(), deconstruct_array(), do_set_block_offsets(), EA_get_flat_size(), estimate_array_length(), ExecEvalArrayExpr(), ExecEvalHashedScalarArrayOp(), ExecEvalScalarArrayOp(), get_text_array_contents(), getWeights(), hash_array(), hash_array_extended(), is_strict_saop(), lt_q_regex(), makeArrayResultArr(), pg_isolation_test_session_is_blocked(), predicate_classify(), sanity_check_tid_array(), width_bucket_array_fixed(), width_bucket_array_float8(), and width_bucket_array_variable().

ArrayGetNItemsSafe()

int ArrayGetNItemsSafe ( int  ndim, const int *  dims, struct Node *  escontext  )

extern

Definition at line 67 of file arrayutils.c.

{
    int32       ret;
    int         i;
 
    if (ndim <= 0)
        return 0;
    ret = 1;
    for (i = 0; i < ndim; i++)
    {
        int64       prod;
 
        /* A negative dimension implies that UB-LB overflowed ... */
        if (dims[i] < 0)
            ereturn(escontext, -1,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array size exceeds the maximum allowed (%d)",
                            (int) MaxArraySize)));
 
        prod = (int64) ret * (int64) dims[i];
 
        ret = (int32) prod;
        if ((int64) ret != prod)
            ereturn(escontext, -1,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array size exceeds the maximum allowed (%d)",
                            (int) MaxArraySize)));
    }
    Assert(ret >= 0);
    if ((Size) ret > MaxArraySize)
        ereturn(escontext, -1,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("array size exceeds the maximum allowed (%d)",
                        (int) MaxArraySize)));
    return (int) ret;
}

References Assert, ereturn, errcode(), errmsg(), fb(), i, and MaxArraySize.

Referenced by ArrayGetNItems().

ArrayGetOffset()

int ArrayGetOffset ( int  n, const int *  dim, const int *  lb, const int *  indx  )

extern

Definition at line 32 of file arrayutils.c.

{
    int         i,
                scale = 1,
                offset = 0;
 
    for (i = n - 1; i >= 0; i--)
    {
        offset += (indx[i] - lb[i]) * scale;
        scale *= dim[i];
    }
    return offset;
}

References fb(), i, and scale.

Referenced by array_extract_slice(), array_get_element(), array_get_element_expanded(), array_insert_slice(), array_set_element(), array_set_element_expanded(), and array_slice_size().

construct_array()

ArrayType * construct_array ( Datum *  elems, int  nelems, Oid  elmtype, int  elmlen, bool  elmbyval, char  elmalign  )

extern

Definition at line 3367 of file arrayfuncs.c.

{
    int         dims[1];
    int         lbs[1];
 
    dims[0] = nelems;
    lbs[0] = 1;
 
    return construct_md_array(elems, NULL, 1, dims, lbs,
                              elmtype, elmlen, elmbyval, elmalign);
}

References construct_md_array(), and fb().

Referenced by ATExecAlterColumnType(), construct_array_builtin(), enum_range_internal(), serialize_expr_stats(), StoreAttrMissingVal(), and update_attstats().

construct_array_builtin()

ArrayType * construct_array_builtin ( Datum *  elems, int  nelems, Oid  elmtype  )

extern

Definition at line 3387 of file arrayfuncs.c.

{
    int         elmlen;
    bool        elmbyval;
    char        elmalign;
 
    switch (elmtype)
    {
        case CHAROID:
            elmlen = 1;
            elmbyval = true;
            elmalign = TYPALIGN_CHAR;
            break;
 
        case CSTRINGOID:
            elmlen = -2;
            elmbyval = false;
            elmalign = TYPALIGN_CHAR;
            break;
 
        case FLOAT4OID:
            elmlen = sizeof(float4);
            elmbyval = true;
            elmalign = TYPALIGN_INT;
            break;
 
        case FLOAT8OID:
            elmlen = sizeof(float8);
            elmbyval = true;
            elmalign = TYPALIGN_DOUBLE;
            break;
 
        case INT2OID:
            elmlen = sizeof(int16);
            elmbyval = true;
            elmalign = TYPALIGN_SHORT;
            break;
 
        case INT4OID:
            elmlen = sizeof(int32);
            elmbyval = true;
            elmalign = TYPALIGN_INT;
            break;
 
        case INT8OID:
            elmlen = sizeof(int64);
            elmbyval = true;
            elmalign = TYPALIGN_DOUBLE;
            break;
 
        case NAMEOID:
            elmlen = NAMEDATALEN;
            elmbyval = false;
            elmalign = TYPALIGN_CHAR;
            break;
 
        case OIDOID:
        case REGTYPEOID:
            elmlen = sizeof(Oid);
            elmbyval = true;
            elmalign = TYPALIGN_INT;
            break;
 
        case TEXTOID:
            elmlen = -1;
            elmbyval = false;
            elmalign = TYPALIGN_INT;
            break;
 
        case TIDOID:
            elmlen = sizeof(ItemPointerData);
            elmbyval = false;
            elmalign = TYPALIGN_SHORT;
            break;
 
        case XIDOID:
            elmlen = sizeof(TransactionId);
            elmbyval = true;
            elmalign = TYPALIGN_INT;
            break;
 
        default:
            elog(ERROR, "type %u not supported by construct_array_builtin()", elmtype);
            /* keep compiler quiet */
            elmlen = 0;
            elmbyval = false;
            elmalign = 0;
    }
 
    return construct_array(elems, nelems, elmtype, elmlen, elmbyval, elmalign);
}

References construct_array(), elog, ERROR, fb(), and NAMEDATALEN.

Referenced by AlterPolicy(), attribute_statistics_update(), bt_page_print_tuples(), build_regtype_array(), convert_requires_to_datum(), CreateConstraintEntry(), CreateFunction(), CreatePolicy(), CreateStatistics(), current_schemas(), executeItemOptUnwrapTarget(), extension_config_remove(), filter_list_to_array(), float4_accum(), float8_accum(), float8_combine(), float8_regr_accum(), float8_regr_combine(), get_environ(), get_hba_options(), GetWALBlockInfo(), gin_leafpage_items(), gin_page_opaque_info(), gist_page_opaque_info(), GUCArrayAdd(), GUCArrayDelete(), GUCArrayReset(), hash_metapage_info(), heap_tuple_infomask_flags(), hstore_akeys(), int_list_to_array(), interpret_function_parameter_list(), makeMultirangeConstructors(), pg_blocking_pids(), pg_extension_config_dump(), pg_get_logical_snapshot_info(), pg_safe_snapshot_blocking_pids(), pg_settings_get_flags(), publicationListToArray(), RemoveRoleFromObjectPolicy(), serialize_expr_stats(), show_trgm(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), test_text_to_wchars(), ts_lexize(), tsvector_to_array(), tsvector_unnest(), typenameTypeMod(), and update_attstats().

construct_empty_array()

ArrayType * construct_empty_array ( Oid  elmtype )

extern

Definition at line 3587 of file arrayfuncs.c.

{
    ArrayType  *result;
 
    result = palloc0_object(ArrayType);
    SET_VARSIZE(result, sizeof(ArrayType));
    result->ndim = 0;
    result->dataoffset = 0;
    result->elemtype = elmtype;
    return result;
}

References ArrayType::dataoffset, ArrayType::elemtype, fb(), ArrayType::ndim, palloc0_object, and SET_VARSIZE().

Referenced by array_fill_internal(), array_get_slice(), array_in(), array_map(), array_recv(), array_replace_internal(), array_shuffle_n(), array_subscript_assign(), array_subscript_assign_slice(), construct_empty_expanded_array(), construct_md_array(), ExecEvalArrayExpr(), heap_tuple_infomask_flags(), hstore_akeys(), hstore_avals(), hstore_slice_to_array(), hstore_to_array_internal(), makeArrayResultArr(), new_intArrayType(), percentile_cont_multi_final_common(), percentile_disc_multi_final(), pg_event_trigger_dropped_objects(), pg_identify_object_as_address(), plperl_array_to_datum(), PLySequence_ToArray(), resize_intArrayType(), text_to_array(), and transformGenericOptions().

construct_empty_expanded_array()

ExpandedArrayHeader * construct_empty_expanded_array ( Oid  element_type, MemoryContext  parentcontext, ArrayMetaState *  metacache  )

extern

Definition at line 3604 of file arrayfuncs.c.

{
    ArrayType  *array = construct_empty_array(element_type);
    Datum       d;
 
    d = expand_array(PointerGetDatum(array), parentcontext, metacache);
    pfree(array);
    return (ExpandedArrayHeader *) DatumGetEOHP(d);
}

References construct_empty_array(), DatumGetEOHP(), expand_array(), fb(), pfree(), and PointerGetDatum().

Referenced by fetch_array_arg_replace_nulls().

construct_md_array()

ArrayType * construct_md_array ( Datum *  elems, bool *  nulls, int  ndims, int *  dims, int *  lbs, Oid  elmtype, int  elmlen, bool  elmbyval, char  elmalign  )

extern

Definition at line 3500 of file arrayfuncs.c.

{
    ArrayType  *result;
    bool        hasnulls;
    int32       nbytes;
    int32       dataoffset;
    int         i;
    int         nelems;
    uint8       elmalignby = typalign_to_alignby(elmalign);
 
    if (ndims < 0)              /* we do allow zero-dimension arrays */
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid number of dimensions: %d", ndims)));
    if (ndims > MAXDIM)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
                        ndims, MAXDIM)));
 
    /* This checks for overflow of the array dimensions */
    nelems = ArrayGetNItems(ndims, dims);
    ArrayCheckBounds(ndims, dims, lbs);
 
    /* if ndims <= 0 or any dims[i] == 0, return empty array */
    if (nelems <= 0)
        return construct_empty_array(elmtype);
 
    /* compute required space */
    nbytes = 0;
    hasnulls = false;
    for (i = 0; i < nelems; i++)
    {
        if (nulls && nulls[i])
        {
            hasnulls = true;
            continue;
        }
        /* make sure data is not toasted */
        if (elmlen == -1)
            elems[i] = PointerGetDatum(PG_DETOAST_DATUM(elems[i]));
        nbytes = att_addlength_datum(nbytes, elmlen, elems[i]);
        nbytes = att_nominal_alignby(nbytes, elmalignby);
        /* check for overflow of total request */
        if (!AllocSizeIsValid(nbytes))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array size exceeds the maximum allowed (%zu)",
                            MaxAllocSize)));
    }
 
    /* Allocate and initialize result array */
    if (hasnulls)
    {
        dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nelems);
        nbytes += dataoffset;
    }
    else
    {
        dataoffset = 0;         /* marker for no null bitmap */
        nbytes += ARR_OVERHEAD_NONULLS(ndims);
    }
    result = (ArrayType *) palloc0(nbytes);
    SET_VARSIZE(result, nbytes);
    result->ndim = ndims;
    result->dataoffset = dataoffset;
    result->elemtype = elmtype;
    memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
    memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));
 
    CopyArrayEls(result,
                 elems, nulls, nelems,
                 elmlen, elmbyval, elmalign,
                 false);
 
    return result;
}

References AllocSizeIsValid, ARR_DIMS, ARR_LBOUND, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ArrayCheckBounds(), ArrayGetNItems(), att_addlength_datum, att_nominal_alignby, construct_empty_array(), CopyArrayEls(), ArrayType::dataoffset, ArrayType::elemtype, ereport, errcode(), errmsg(), ERROR, fb(), i, MaxAllocSize, MAXDIM, ArrayType::ndim, palloc0(), PG_DETOAST_DATUM, PointerGetDatum(), SET_VARSIZE(), and typalign_to_alignby().

Referenced by array_iterate(), array_reverse_n(), array_set_element(), array_set_slice(), array_shuffle_n(), build_regexp_match_result(), build_test_info_result(), build_test_match_result(), construct_array(), ExecEvalArrayExpr(), hstore_avals(), hstore_slice_to_array(), hstore_to_array_internal(), make_SAOP_expr(), makeMdArrayResult(), percentile_cont_multi_final_common(), percentile_disc_multi_final(), plpgsql_fulfill_promise(), and strlist_to_textarray().

CopyArrayEls()

void CopyArrayEls ( ArrayType *  array, const Datum *  values, const bool *  nulls, int  nitems, int  typlen, bool  typbyval, char  typalign, bool  freedata  )

extern

Definition at line 965 of file arrayfuncs.c.

{
    char       *p = ARR_DATA_PTR(array);
    bits8      *bitmap = ARR_NULLBITMAP(array);
    int         bitval = 0;
    int         bitmask = 1;
    uint8       typalignby = typalign_to_alignby(typalign);
    int         i;
 
    if (typbyval)
        freedata = false;
 
    for (i = 0; i < nitems; i++)
    {
        if (nulls && nulls[i])
        {
            if (!bitmap)        /* shouldn't happen */
                elog(ERROR, "null array element where not supported");
            /* bitmap bit stays 0 */
        }
        else
        {
            bitval |= bitmask;
            p += ArrayCastAndSet(values[i], typlen, typbyval, typalignby, p);
            if (freedata)
                pfree(DatumGetPointer(values[i]));
        }
        if (bitmap)
        {
            bitmask <<= 1;
            if (bitmask == 0x100)
            {
                *bitmap++ = bitval;
                bitval = 0;
                bitmask = 1;
            }
        }
    }
 
    if (bitmap && bitmask != 1)
        *bitmap = bitval;
}

References ARR_DATA_PTR, ARR_NULLBITMAP, ArrayCastAndSet(), DatumGetPointer(), elog, ERROR, fb(), i, nitems, pfree(), typalign, typalign_to_alignby(), and values.

Referenced by array_in(), array_map(), array_recv(), array_replace_internal(), construct_md_array(), and EA_flatten_into().

DatumGetAnyArrayP()

AnyArrayType * DatumGetAnyArrayP ( Datum  d )

extern

Definition at line 403 of file array_expanded.c.

{
    ExpandedArrayHeader *eah;
 
    /*
     * If it's an expanded array (RW or RO), return the header pointer.
     */
    if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(d)))
    {
        eah = (ExpandedArrayHeader *) DatumGetEOHP(d);
        Assert(eah->ea_magic == EA_MAGIC);
        return (AnyArrayType *) eah;
    }
 
    /* Else do regular detoasting as needed */
    return (AnyArrayType *) PG_DETOAST_DATUM(d);
}

References Assert, DatumGetEOHP(), DatumGetPointer(), EA_MAGIC, fb(), PG_DETOAST_DATUM, and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by array_map().

DatumGetExpandedArray()

ExpandedArrayHeader * DatumGetExpandedArray ( Datum  d )

extern

Definition at line 354 of file array_expanded.c.

{
    /* If it's a writable expanded array already, just return it */
    if (VARATT_IS_EXTERNAL_EXPANDED_RW(DatumGetPointer(d)))
    {
        ExpandedArrayHeader *eah = (ExpandedArrayHeader *) DatumGetEOHP(d);
 
        Assert(eah->ea_magic == EA_MAGIC);
        return eah;
    }
 
    /* Else expand the hard way */
    d = expand_array(d, CurrentMemoryContext, NULL);
    return (ExpandedArrayHeader *) DatumGetEOHP(d);
}

References Assert, CurrentMemoryContext, DatumGetEOHP(), DatumGetPointer(), EA_MAGIC, expand_array(), fb(), and VARATT_IS_EXTERNAL_EXPANDED_RW().

Referenced by array_set_element_expanded(), and statext_expressions_load().

DatumGetExpandedArrayX()

ExpandedArrayHeader * DatumGetExpandedArrayX ( Datum  d, ArrayMetaState *  metacache  )

extern

Definition at line 374 of file array_expanded.c.

{
    /* If it's a writable expanded array already, just return it */
    if (VARATT_IS_EXTERNAL_EXPANDED_RW(DatumGetPointer(d)))
    {
        ExpandedArrayHeader *eah = (ExpandedArrayHeader *) DatumGetEOHP(d);
 
        Assert(eah->ea_magic == EA_MAGIC);
        /* Update cache if provided */
        if (metacache)
        {
            metacache->element_type = eah->element_type;
            metacache->typlen = eah->typlen;
            metacache->typbyval = eah->typbyval;
            metacache->typalign = eah->typalign;
        }
        return eah;
    }
 
    /* Else expand using caller's cache if any */
    d = expand_array(d, CurrentMemoryContext, metacache);
    return (ExpandedArrayHeader *) DatumGetEOHP(d);
}

References Assert, CurrentMemoryContext, DatumGetEOHP(), DatumGetPointer(), EA_MAGIC, expand_array(), fb(), and VARATT_IS_EXTERNAL_EXPANDED_RW().

deconstruct_array()

void deconstruct_array ( const ArrayType *  array, Oid  elmtype, int  elmlen, bool  elmbyval, char  elmalign, Datum **  elemsp, bool **  nullsp, int *  nelemsp  )

extern

Definition at line 3638 of file arrayfuncs.c.

{
    Datum      *elems;
    bool       *nulls;
    int         nelems;
    char       *p;
    bits8      *bitmap;
    int         bitmask;
    int         i;
    uint8       elmalignby = typalign_to_alignby(elmalign);
 
    Assert(ARR_ELEMTYPE(array) == elmtype);
 
    nelems = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
    *elemsp = elems = palloc_array(Datum, nelems);
    if (nullsp)
        *nullsp = nulls = palloc0_array(bool, nelems);
    else
        nulls = NULL;
    *nelemsp = nelems;
 
    p = ARR_DATA_PTR(array);
    bitmap = ARR_NULLBITMAP(array);
    bitmask = 1;
 
    for (i = 0; i < nelems; i++)
    {
        /* Get source element, checking for NULL */
        if (bitmap && (*bitmap & bitmask) == 0)
        {
            elems[i] = (Datum) 0;
            if (nulls)
                nulls[i] = true;
            else
                ereport(ERROR,
                        (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                         errmsg("null array element not allowed in this context")));
        }
        else
        {
            elems[i] = fetch_att(p, elmbyval, elmlen);
            p = att_addlength_pointer(p, elmlen, p);
            p = (char *) att_nominal_alignby(p, elmalignby);
        }
 
        /* advance bitmap pointer if any */
        if (bitmap)
        {
            bitmask <<= 1;
            if (bitmask == 0x100)
            {
                bitmap++;
                bitmask = 1;
            }
        }
    }
}

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), Assert, att_addlength_pointer, att_nominal_alignby, ereport, errcode(), errmsg(), ERROR, fb(), fetch_att(), i, palloc0_array, palloc_array, and typalign_to_alignby().

Referenced by _bt_preprocess_array_keys(), array_contain_compare(), array_reverse_n(), array_set_slice(), array_shuffle_n(), array_to_json_internal(), array_to_jsonb_internal(), arrayconst_startup_fn(), compute_array_stats(), deconstruct_array_builtin(), deconstruct_expanded_array(), ExecIndexEvalArrayKeys(), extract_variadic_args(), get_attstatsslot(), ginarrayextract(), gincost_scalararrayopexpr(), ginqueryarrayextract(), map_sql_value_to_xml_value(), match_clause_to_partition_key(), mcelem_array_selec(), mcv_get_match_bitmap(), multirange_constructor2(), plperl_ref_from_pg_array(), satisfies_hash_partition(), scalararraysel(), test_bms_overlap_list(), and text_format().

deconstruct_array_builtin()

void deconstruct_array_builtin ( const ArrayType *  array, Oid  elmtype, Datum **  elemsp, bool **  nullsp, int *  nelemsp  )

extern

Definition at line 3705 of file arrayfuncs.c.

{
    int         elmlen;
    bool        elmbyval;
    char        elmalign;
 
    switch (elmtype)
    {
        case CHAROID:
            elmlen = 1;
            elmbyval = true;
            elmalign = TYPALIGN_CHAR;
            break;
 
        case CSTRINGOID:
            elmlen = -2;
            elmbyval = false;
            elmalign = TYPALIGN_CHAR;
            break;
 
        case FLOAT8OID:
            elmlen = sizeof(float8);
            elmbyval = true;
            elmalign = TYPALIGN_DOUBLE;
            break;
 
        case INT2OID:
            elmlen = sizeof(int16);
            elmbyval = true;
            elmalign = TYPALIGN_SHORT;
            break;
 
        case INT4OID:
            elmlen = sizeof(int32);
            elmbyval = true;
            elmalign = TYPALIGN_INT;
            break;
 
        case OIDOID:
            elmlen = sizeof(Oid);
            elmbyval = true;
            elmalign = TYPALIGN_INT;
            break;
 
        case TEXTOID:
            elmlen = -1;
            elmbyval = false;
            elmalign = TYPALIGN_INT;
            break;
 
        case TIDOID:
            elmlen = sizeof(ItemPointerData);
            elmbyval = false;
            elmalign = TYPALIGN_SHORT;
            break;
 
        default:
            elog(ERROR, "type %u not supported by deconstruct_array_builtin()", elmtype);
            /* keep compiler quiet */
            elmlen = 0;
            elmbyval = false;
            elmalign = 0;
    }
 
    deconstruct_array(array, elmtype, elmlen, elmbyval, elmalign, elemsp, nullsp, nelemsp);
}

References deconstruct_array(), elog, ERROR, and fb().

Referenced by array_to_tsvector(), ArrayGetIntegerTypmods(), binary_upgrade_create_empty_extension(), build_function_result_tupdesc_d(), DecodeTextArrayToBitmapset(), decompile_column_index_array(), extension_config_remove(), generateClonedIndexStmt(), get_func_arg_info(), get_func_input_arg_names(), get_func_result_name(), get_jsonb_path_all(), get_path_all(), get_reloptions(), ghstore_consistent(), gin_extract_hstore_query(), gin_extract_jsonb_query(), hstore_from_array(), hstore_from_arrays(), hstore_slice_to_array(), hstoreArrayToPairs(), import_mcv(), InsertOneProargdefaultsValue(), json_object(), json_object_two_arg(), jsonb_delete_array(), jsonb_delete_path(), jsonb_exists_all(), jsonb_exists_any(), jsonb_insert(), jsonb_object(), jsonb_object_two_arg(), jsonb_set(), oid_array_to_list(), parse_key_value_arrays(), parseRelOptionsInternal(), percentile_cont_multi_final_common(), percentile_disc_multi_final(), pg_get_constraintdef_worker(), pg_get_object_address(), pg_get_publication_tables(), pg_logical_slot_get_changes_guts(), test_wchars_to_text(), textarray_to_stringlist(), textarray_to_strvaluelist(), TidListEval(), transformRelOptions(), tsvector_delete_arr(), tsvector_filter(), tsvector_setweight_by_filter(), untransformRelOptions(), and worker_spi_launch().

deconstruct_expanded_array()

void deconstruct_expanded_array ( ExpandedArrayHeader *  eah )

extern

Definition at line 426 of file array_expanded.c.

{
    if (eah->dvalues == NULL)
    {
        MemoryContext oldcxt = MemoryContextSwitchTo(eah->hdr.eoh_context);
        Datum      *dvalues;
        bool       *dnulls;
        int         nelems;
 
        dnulls = NULL;
        deconstruct_array(eah->fvalue,
                          eah->element_type,
                          eah->typlen, eah->typbyval, eah->typalign,
                          &dvalues,
                          ARR_HASNULL(eah->fvalue) ? &dnulls : NULL,
                          &nelems);
 
        /*
         * Update header only after successful completion of this step.  If
         * deconstruct_array fails partway through, worst consequence is some
         * leaked memory in the object's context.  If the caller fails at a
         * later point, that's fine, since the deconstructed representation is
         * valid anyhow.
         */
        eah->dvalues = dvalues;
        eah->dnulls = dnulls;
        eah->dvalueslen = eah->nelems = nelems;
        MemoryContextSwitchTo(oldcxt);
    }
}

References ARR_HASNULL, deconstruct_array(), fb(), and MemoryContextSwitchTo().

Referenced by array_contain_compare(), array_get_element_expanded(), array_set_element_expanded(), and statext_expressions_load().

expand_array()

Datum expand_array ( Datum  arraydatum, MemoryContext  parentcontext, ArrayMetaState *  metacache  )

extern

Definition at line 50 of file array_expanded.c.

{
    ArrayType  *array;
    ExpandedArrayHeader *eah;
    MemoryContext objcxt;
    MemoryContext oldcxt;
    ArrayMetaState fakecache;
 
    /*
     * Allocate private context for expanded object.  We start by assuming
     * that the array won't be very large; but if it does grow a lot, don't
     * constrain aset.c's large-context behavior.
     */
    objcxt = AllocSetContextCreate(parentcontext,
                                   "expanded array",
                                   ALLOCSET_START_SMALL_SIZES);
 
    /* Set up expanded array header */
    eah = (ExpandedArrayHeader *)
        MemoryContextAlloc(objcxt, sizeof(ExpandedArrayHeader));
 
    EOH_init_header(&eah->hdr, &EA_methods, objcxt);
    eah->ea_magic = EA_MAGIC;
 
    /* If the source is an expanded array, we may be able to optimize */
    if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(arraydatum)))
    {
        ExpandedArrayHeader *oldeah = (ExpandedArrayHeader *) DatumGetEOHP(arraydatum);
 
        Assert(oldeah->ea_magic == EA_MAGIC);
 
        /*
         * Update caller's cache if provided; we don't need it this time, but
         * next call might be for a non-expanded source array.  Furthermore,
         * if the caller didn't provide a cache area, use some local storage
         * to cache anyway, thereby avoiding a catalog lookup in the case
         * where we fall through to the flat-copy code path.
         */
        if (metacache == NULL)
            metacache = &fakecache;
        metacache->element_type = oldeah->element_type;
        metacache->typlen = oldeah->typlen;
        metacache->typbyval = oldeah->typbyval;
        metacache->typalign = oldeah->typalign;
 
        /*
         * If element type is pass-by-value and we have a Datum-array
         * representation, just copy the source's metadata and Datum/isnull
         * arrays.  The original flat array, if present at all, adds no
         * additional information so we need not copy it.
         */
        if (oldeah->typbyval && oldeah->dvalues != NULL)
        {
            copy_byval_expanded_array(eah, oldeah);
            /* return a R/W pointer to the expanded array */
            return EOHPGetRWDatum(&eah->hdr);
        }
 
        /*
         * Otherwise, either we have only a flat representation or the
         * elements are pass-by-reference.  In either case, the best thing
         * seems to be to copy the source as a flat representation and then
         * deconstruct that later if necessary.  For the pass-by-ref case, we
         * could perhaps save some cycles with custom code that generates the
         * deconstructed representation in parallel with copying the values,
         * but it would be a lot of extra code for fairly marginal gain.  So,
         * fall through into the flat-source code path.
         */
    }
 
    /*
     * Detoast and copy source array into private context, as a flat array.
     *
     * Note that this coding risks leaking some memory in the private context
     * if we have to fetch data from a TOAST table; however, experimentation
     * says that the leak is minimal.  Doing it this way saves a copy step,
     * which seems worthwhile, especially if the array is large enough to need
     * external storage.
     */
    oldcxt = MemoryContextSwitchTo(objcxt);
    array = DatumGetArrayTypePCopy(arraydatum);
    MemoryContextSwitchTo(oldcxt);
 
    eah->ndims = ARR_NDIM(array);
    /* note these pointers point into the fvalue header! */
    eah->dims = ARR_DIMS(array);
    eah->lbound = ARR_LBOUND(array);
 
    /* Save array's element-type data for possible use later */
    eah->element_type = ARR_ELEMTYPE(array);
    if (metacache && metacache->element_type == eah->element_type)
    {
        /* We have a valid cache of representational data */
        eah->typlen = metacache->typlen;
        eah->typbyval = metacache->typbyval;
        eah->typalign = metacache->typalign;
    }
    else
    {
        /* No, so look it up */
        get_typlenbyvalalign(eah->element_type,
                             &eah->typlen,
                             &eah->typbyval,
                             &eah->typalign);
        /* Update cache if provided */
        if (metacache)
        {
            metacache->element_type = eah->element_type;
            metacache->typlen = eah->typlen;
            metacache->typbyval = eah->typbyval;
            metacache->typalign = eah->typalign;
        }
    }
 
    /* we don't make a deconstructed representation now */
    eah->dvalues = NULL;
    eah->dnulls = NULL;
    eah->dvalueslen = 0;
    eah->nelems = 0;
    eah->flat_size = 0;
 
    /* remember we have a flat representation */
    eah->fvalue = array;
    eah->fstartptr = ARR_DATA_PTR(array);
    eah->fendptr = ((char *) array) + ARR_SIZE(array);
 
    /* return a R/W pointer to the expanded array */
    return EOHPGetRWDatum(&eah->hdr);
}

References ALLOCSET_START_SMALL_SIZES, AllocSetContextCreate, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, ARR_SIZE, Assert, copy_byval_expanded_array(), DatumGetArrayTypePCopy, DatumGetEOHP(), DatumGetPointer(), EA_MAGIC, EA_methods, EOH_init_header(), EOHPGetRWDatum(), fb(), get_typlenbyvalalign(), MemoryContextAlloc(), MemoryContextSwitchTo(), and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by construct_empty_expanded_array(), DatumGetExpandedArray(), DatumGetExpandedArrayX(), exec_assign_value(), and plpgsql_exec_function().

initArrayResult()

ArrayBuildState * initArrayResult ( Oid  element_type, MemoryContext  rcontext, bool  subcontext  )

extern

Definition at line 5308 of file arrayfuncs.c.

{
    /*
     * When using a subcontext, we can afford to start with a somewhat larger
     * initial array size.  Without subcontexts, we'd better hope that most of
     * the states stay small ...
     */
    return initArrayResultWithSize(element_type, rcontext, subcontext,
                                   subcontext ? 64 : 8);
}

References fb(), and initArrayResultWithSize().

Referenced by accumArrayResult(), array_agg_transfn(), array_positions(), array_to_datum_internal(), daitch_mokotoff(), initArrayResultAny(), multirange_agg_transfn(), PLySequence_ToArray_recurse(), populate_array(), range_agg_transfn(), tuple_data_split_internal(), and xpath().

initArrayResultAny()

ArrayBuildStateAny * initArrayResultAny ( Oid  input_type, MemoryContext  rcontext, bool  subcontext  )

extern

Definition at line 5797 of file arrayfuncs.c.

{
    ArrayBuildStateAny *astate;
 
    /*
     * int2vector and oidvector will satisfy both get_element_type and
     * get_array_type.  We prefer to treat them as scalars, to be consistent
     * with get_promoted_array_type.  Hence, check get_array_type not
     * get_element_type.
     */
    if (!OidIsValid(get_array_type(input_type)))
    {
        /* Array case */
        ArrayBuildStateArr *arraystate;
 
        arraystate = initArrayResultArr(input_type, InvalidOid, rcontext, subcontext);
        astate = (ArrayBuildStateAny *)
            MemoryContextAlloc(arraystate->mcontext,
                               sizeof(ArrayBuildStateAny));
        astate->scalarstate = NULL;
        astate->arraystate = arraystate;
    }
    else
    {
        /* Scalar case */
        ArrayBuildState *scalarstate;
 
        scalarstate = initArrayResult(input_type, rcontext, subcontext);
        astate = (ArrayBuildStateAny *)
            MemoryContextAlloc(scalarstate->mcontext,
                               sizeof(ArrayBuildStateAny));
        astate->scalarstate = scalarstate;
        astate->arraystate = NULL;
    }
 
    return astate;
}

References ArrayBuildStateAny::arraystate, fb(), get_array_type(), initArrayResult(), initArrayResultArr(), InvalidOid, ArrayBuildState::mcontext, ArrayBuildStateArr::mcontext, MemoryContextAlloc(), OidIsValid, and ArrayBuildStateAny::scalarstate.

Referenced by accumArrayResultAny(), ExecScanSubPlan(), and ExecSetParamPlan().

initArrayResultArr()

ArrayBuildStateArr * initArrayResultArr ( Oid  array_type, Oid  element_type, MemoryContext  rcontext, bool  subcontext  )

extern

Definition at line 5519 of file arrayfuncs.c.

{
    ArrayBuildStateArr *astate;
    MemoryContext arr_context = rcontext;   /* by default use the parent ctx */
 
    /* Lookup element type, unless element_type already provided */
    if (!OidIsValid(element_type))
    {
        element_type = get_element_type(array_type);
 
        if (!OidIsValid(element_type))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("data type %s is not an array type",
                            format_type_be(array_type))));
    }
 
    /* Make a temporary context to hold all the junk */
    if (subcontext)
        arr_context = AllocSetContextCreate(rcontext,
                                            "accumArrayResultArr",
                                            ALLOCSET_DEFAULT_SIZES);
 
    /* Note we initialize all fields to zero */
    astate = (ArrayBuildStateArr *)
        MemoryContextAllocZero(arr_context, sizeof(ArrayBuildStateArr));
    astate->mcontext = arr_context;
    astate->private_cxt = subcontext;
 
    /* Save relevant datatype information */
    astate->array_type = array_type;
    astate->element_type = element_type;
 
    return astate;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ArrayBuildStateArr::array_type, ArrayBuildStateArr::element_type, ereport, errcode(), errmsg(), ERROR, fb(), format_type_be(), get_element_type(), ArrayBuildStateArr::mcontext, MemoryContextAllocZero(), OidIsValid, and ArrayBuildStateArr::private_cxt.

Referenced by accumArrayResultArr(), array_agg_array_combine(), array_agg_array_deserialize(), array_agg_array_transfn(), and initArrayResultAny().

initArrayResultWithSize()

ArrayBuildState * initArrayResultWithSize ( Oid  element_type, MemoryContext  rcontext, bool  subcontext, int  initsize  )

extern

Definition at line 5325 of file arrayfuncs.c.

{
    ArrayBuildState *astate;
    MemoryContext arr_context = rcontext;
 
    /* Make a temporary context to hold all the junk */
    if (subcontext)
        arr_context = AllocSetContextCreate(rcontext,
                                            "accumArrayResult",
                                            ALLOCSET_DEFAULT_SIZES);
 
    astate = (ArrayBuildState *)
        MemoryContextAlloc(arr_context, sizeof(ArrayBuildState));
    astate->mcontext = arr_context;
    astate->private_cxt = subcontext;
    astate->alen = initsize;
    astate->dvalues = (Datum *)
        MemoryContextAlloc(arr_context, astate->alen * sizeof(Datum));
    astate->dnulls = (bool *)
        MemoryContextAlloc(arr_context, astate->alen * sizeof(bool));
    astate->nelems = 0;
    astate->element_type = element_type;
    get_typlenbyvalalign(element_type,
                         &astate->typlen,
                         &astate->typbyval,
                         &astate->typalign);
 
    return astate;
}

References ArrayBuildState::alen, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ArrayBuildState::dnulls, ArrayBuildState::dvalues, ArrayBuildState::element_type, fb(), get_typlenbyvalalign(), ArrayBuildState::mcontext, MemoryContextAlloc(), ArrayBuildState::nelems, ArrayBuildState::private_cxt, ArrayBuildState::typalign, ArrayBuildState::typbyval, and ArrayBuildState::typlen.

Referenced by array_agg_combine(), array_agg_deserialize(), and initArrayResult().

makeArrayResult()

Datum makeArrayResult ( ArrayBuildState *  astate, MemoryContext  rcontext  )

extern

Definition at line 5435 of file arrayfuncs.c.

{
    int         ndims;
    int         dims[1];
    int         lbs[1];
 
    /* If no elements were presented, we want to create an empty array */
    ndims = (astate->nelems > 0) ? 1 : 0;
    dims[0] = astate->nelems;
    lbs[0] = 1;
 
    return makeMdArrayResult(astate, ndims, dims, lbs, rcontext,
                             astate->private_cxt);
}

References fb(), makeMdArrayResult(), ArrayBuildState::nelems, and ArrayBuildState::private_cxt.

Referenced by array_positions(), brin_minmax_multi_summary_out(), daitch_mokotoff(), dblink_get_connections(), optionListToArray(), parse_ident(), pg_get_statisticsobjdef_expressions(), pg_stats_ext_mcvlist_items(), regexp_split_to_array(), serialize_expr_stats(), text_to_array(), transformRelOptions(), tuple_data_split_internal(), and xpath().

makeArrayResultAny()

Datum makeArrayResultAny ( ArrayBuildStateAny *  astate, MemoryContext  rcontext, bool  release  )

extern

Definition at line 5872 of file arrayfuncs.c.

{
    Datum       result;
 
    if (astate->scalarstate)
    {
        /* Must use makeMdArrayResult to support "release" parameter */
        int         ndims;
        int         dims[1];
        int         lbs[1];
 
        /* If no elements were presented, we want to create an empty array */
        ndims = (astate->scalarstate->nelems > 0) ? 1 : 0;
        dims[0] = astate->scalarstate->nelems;
        lbs[0] = 1;
 
        result = makeMdArrayResult(astate->scalarstate, ndims, dims, lbs,
                                   rcontext, release);
    }
    else
    {
        result = makeArrayResultArr(astate->arraystate,
                                    rcontext, release);
    }
    return result;
}

References ArrayBuildStateAny::arraystate, fb(), makeArrayResultArr(), makeMdArrayResult(), ArrayBuildState::nelems, and ArrayBuildStateAny::scalarstate.

Referenced by array_sort_internal(), ExecScanSubPlan(), and ExecSetParamPlan().

makeArrayResultArr()

Datum makeArrayResultArr ( ArrayBuildStateArr *  astate, MemoryContext  rcontext, bool  release  )

extern

Definition at line 5718 of file arrayfuncs.c.

{
    ArrayType  *result;
    MemoryContext oldcontext;
 
    /* Build the final array result in rcontext */
    oldcontext = MemoryContextSwitchTo(rcontext);
 
    if (astate->ndims == 0)
    {
        /* No inputs, return empty array */
        result = construct_empty_array(astate->element_type);
    }
    else
    {
        int         dataoffset,
                    nbytes;
 
        /* Check for overflow of the array dimensions */
        (void) ArrayGetNItems(astate->ndims, astate->dims);
        ArrayCheckBounds(astate->ndims, astate->dims, astate->lbs);
 
        /* Compute required space */
        nbytes = astate->nbytes;
        if (astate->nullbitmap != NULL)
        {
            dataoffset = ARR_OVERHEAD_WITHNULLS(astate->ndims, astate->nitems);
            nbytes += dataoffset;
        }
        else
        {
            dataoffset = 0;
            nbytes += ARR_OVERHEAD_NONULLS(astate->ndims);
        }
 
        result = (ArrayType *) palloc0(nbytes);
        SET_VARSIZE(result, nbytes);
        result->ndim = astate->ndims;
        result->dataoffset = dataoffset;
        result->elemtype = astate->element_type;
 
        memcpy(ARR_DIMS(result), astate->dims, astate->ndims * sizeof(int));
        memcpy(ARR_LBOUND(result), astate->lbs, astate->ndims * sizeof(int));
        memcpy(ARR_DATA_PTR(result), astate->data, astate->nbytes);
 
        if (astate->nullbitmap != NULL)
            array_bitmap_copy(ARR_NULLBITMAP(result), 0,
                              astate->nullbitmap, 0,
                              astate->nitems);
    }
 
    MemoryContextSwitchTo(oldcontext);
 
    /* Clean up all the junk */
    if (release)
    {
        Assert(astate->private_cxt);
        MemoryContextDelete(astate->mcontext);
    }
 
    return PointerGetDatum(result);
}

References ARR_DATA_PTR, ARR_DIMS, ARR_LBOUND, ARR_NULLBITMAP, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, array_bitmap_copy(), ArrayCheckBounds(), ArrayGetNItems(), Assert, construct_empty_array(), ArrayBuildStateArr::data, ArrayType::dataoffset, ArrayBuildStateArr::dims, ArrayBuildStateArr::element_type, ArrayType::elemtype, fb(), ArrayBuildStateArr::lbs, ArrayBuildStateArr::mcontext, MemoryContextDelete(), MemoryContextSwitchTo(), ArrayBuildStateArr::nbytes, ArrayType::ndim, ArrayBuildStateArr::ndims, ArrayBuildStateArr::nitems, ArrayBuildStateArr::nullbitmap, palloc0(), PointerGetDatum(), ArrayBuildStateArr::private_cxt, and SET_VARSIZE().

Referenced by array_agg_array_finalfn(), and makeArrayResultAny().

makeMdArrayResult()

Datum makeMdArrayResult ( ArrayBuildState *  astate, int  ndims, int *  dims, int *  lbs, MemoryContext  rcontext, bool  release  )

extern

Definition at line 5467 of file arrayfuncs.c.

{
    ArrayType  *result;
    MemoryContext oldcontext;
 
    /* Build the final array result in rcontext */
    oldcontext = MemoryContextSwitchTo(rcontext);
 
    result = construct_md_array(astate->dvalues,
                                astate->dnulls,
                                ndims,
                                dims,
                                lbs,
                                astate->element_type,
                                astate->typlen,
                                astate->typbyval,
                                astate->typalign);
 
    MemoryContextSwitchTo(oldcontext);
 
    /* Clean up all the junk */
    if (release)
    {
        Assert(astate->private_cxt);
        MemoryContextDelete(astate->mcontext);
    }
 
    return PointerGetDatum(result);
}

References Assert, construct_md_array(), ArrayBuildState::dnulls, ArrayBuildState::dvalues, ArrayBuildState::element_type, fb(), ArrayBuildState::mcontext, MemoryContextDelete(), MemoryContextSwitchTo(), PointerGetDatum(), ArrayBuildState::private_cxt, ArrayBuildState::typalign, ArrayBuildState::typbyval, and ArrayBuildState::typlen.

Referenced by array_agg_finalfn(), makeArrayResult(), makeArrayResultAny(), plperl_array_to_datum(), PLySequence_ToArray(), and populate_array().

mda_get_offset_values()

void mda_get_offset_values ( int  n, int *  dist, const int *  prod, const int *  span  )

extern

Definition at line 183 of file arrayutils.c.

{
    int         i,
                j;
 
    dist[n - 1] = 0;
    for (j = n - 2; j >= 0; j--)
    {
        dist[j] = prod[j] - 1;
        for (i = j + 1; i < n; i++)
            dist[j] -= (span[i] - 1) * prod[i];
    }
}

References fb(), i, and j.

Referenced by array_extract_slice(), array_insert_slice(), and array_slice_size().

mda_get_prod()

void mda_get_prod ( int  n, const int *  range, int *  prod  )

extern

Definition at line 167 of file arrayutils.c.

{
    int         i;
 
    prod[n - 1] = 1;
    for (i = n - 2; i >= 0; i--)
        prod[i] = prod[i + 1] * range[i + 1];
}

References i, and range().

Referenced by array_extract_slice(), array_insert_slice(), and array_slice_size().

mda_get_range()

void mda_get_range ( int  n, int *  span, const int *  st, const int *  endp  )

extern

Definition at line 153 of file arrayutils.c.

{
    int         i;
 
    for (i = 0; i < n; i++)
        span[i] = endp[i] - st[i] + 1;
}

References fb(), and i.

Referenced by array_extract_slice(), array_get_slice(), array_insert_slice(), array_set_slice(), and array_slice_size().

mda_next_tuple()

int mda_next_tuple ( int  n, int *  curr, const int *  span  )

extern

Definition at line 208 of file arrayutils.c.

{
    int         i;
 
    if (n <= 0)
        return -1;
 
    curr[n - 1] = (curr[n - 1] + 1) % span[n - 1];
    for (i = n - 1; i && curr[i] == 0; i--)
        curr[i - 1] = (curr[i - 1] + 1) % span[i - 1];
 
    if (i)
        return i;
    if (curr[0])
        return 0;
 
    return -1;
}

References fb(), and i.

Referenced by array_extract_slice(), array_insert_slice(), and array_slice_size().

Variable Documentation

Array_nulls

PGDLLIMPORT bool Array_nulls

extern

Definition at line 44 of file arrayfuncs.c.

Referenced by ReadArrayToken().