arrayfuncs.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <math.h>
#include "access/transam.h"
#include "catalog/pg_type.h"
#include "common/int.h"
#include "funcapi.h"
#include "libpq/pqformat.h"
#include "nodes/nodeFuncs.h"
#include "nodes/supportnodes.h"
#include "optimizer/optimizer.h"
#include "parser/scansup.h"
#include "port/pg_bitutils.h"
#include "utils/array.h"
#include "utils/arrayaccess.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/selfuncs.h"
#include "utils/typcache.h"

Include dependency graph for arrayfuncs.c:

Go to the source code of this file.

Data Structures
struct	ArrayIteratorData
struct	generate_subscripts_fctx

Macros
#define	ASSGN   "="
#define	AARR_FREE_IF_COPY(array, n)
#define	APPENDSTR(str)   (strcpy(p, (str)), p += strlen(p))
#define	APPENDCHAR(ch)   (*p++ = (ch), *p = '\0')

Typedefs
typedef struct ArrayIteratorData	ArrayIteratorData
typedef struct generate_subscripts_fctx	generate_subscripts_fctx

Enumerations
enum	ArrayToken {   ATOK_LEVEL_START , ATOK_LEVEL_END , ATOK_DELIM , ATOK_ELEM ,   ATOK_ELEM_NULL , ATOK_ERROR }

Functions
static bool	ReadArrayDimensions (char **srcptr, int *ndim_p, int *dim, int *lBound, const char *origStr, Node *escontext)
static bool	ReadDimensionInt (char **srcptr, int *result, const char *origStr, Node *escontext)
static bool	ReadArrayStr (char **srcptr, FmgrInfo *inputproc, Oid typioparam, int32 typmod, char typdelim, int typlen, bool typbyval, char typalign, int *ndim_p, int *dim, int *nitems_p, Datum **values_p, bool **nulls_p, const char *origStr, Node *escontext)
static ArrayToken	ReadArrayToken (char **srcptr, StringInfo elembuf, char typdelim, const char *origStr, Node *escontext)
static void	ReadArrayBinary (StringInfo buf, int nitems, FmgrInfo *receiveproc, Oid typioparam, int32 typmod, int typlen, bool typbyval, char typalign, Datum *values, bool *nulls, bool *hasnulls, int32 *nbytes)
static Datum	array_get_element_expanded (Datum arraydatum, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
static Datum	array_set_element_expanded (Datum arraydatum, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
static bool	array_get_isnull (const bits8 *nullbitmap, int offset)
static void	array_set_isnull (bits8 *nullbitmap, int offset, bool isNull)
static Datum	ArrayCast (char *value, bool byval, int len)
static int	ArrayCastAndSet (Datum src, int typlen, bool typbyval, char typalign, char *dest)
static char *	array_seek (char *ptr, int offset, bits8 *nullbitmap, int nitems, int typlen, bool typbyval, char typalign)
static int	array_nelems_size (char *ptr, int offset, bits8 *nullbitmap, int nitems, int typlen, bool typbyval, char typalign)
static int	array_copy (char *destptr, int nitems, char *srcptr, int offset, bits8 *nullbitmap, int typlen, bool typbyval, char typalign)
static int	array_slice_size (char *arraydataptr, bits8 *arraynullsptr, int ndim, int *dim, int *lb, int *st, int *endp, int typlen, bool typbyval, char typalign)
static void	array_extract_slice (ArrayType *newarray, int ndim, int *dim, int *lb, char *arraydataptr, bits8 *arraynullsptr, int *st, int *endp, int typlen, bool typbyval, char typalign)
static void	array_insert_slice (ArrayType *destArray, ArrayType *origArray, ArrayType *srcArray, int ndim, int *dim, int *lb, int *st, int *endp, int typlen, bool typbyval, char typalign)
static int	array_cmp (FunctionCallInfo fcinfo)
static ArrayType *	create_array_envelope (int ndims, int *dimv, int *lbsv, int nbytes, Oid elmtype, int dataoffset)
static ArrayType *	array_fill_internal (ArrayType *dims, ArrayType *lbs, Datum value, bool isnull, Oid elmtype, FunctionCallInfo fcinfo)
static ArrayType *	array_replace_internal (ArrayType *array, Datum search, bool search_isnull, Datum replace, bool replace_isnull, bool remove, Oid collation, FunctionCallInfo fcinfo)
static int	width_bucket_array_float8 (Datum operand, ArrayType *thresholds)
static int	width_bucket_array_fixed (Datum operand, ArrayType *thresholds, Oid collation, TypeCacheEntry *typentry)
static int	width_bucket_array_variable (Datum operand, ArrayType *thresholds, Oid collation, TypeCacheEntry *typentry)
Datum	array_in (PG_FUNCTION_ARGS)
void	CopyArrayEls (ArrayType *array, Datum *values, bool *nulls, int nitems, int typlen, bool typbyval, char typalign, bool freedata)
Datum	array_out (PG_FUNCTION_ARGS)
Datum	array_recv (PG_FUNCTION_ARGS)
Datum	array_send (PG_FUNCTION_ARGS)
Datum	array_ndims (PG_FUNCTION_ARGS)
Datum	array_dims (PG_FUNCTION_ARGS)
Datum	array_lower (PG_FUNCTION_ARGS)
Datum	array_upper (PG_FUNCTION_ARGS)
Datum	array_length (PG_FUNCTION_ARGS)
Datum	array_cardinality (PG_FUNCTION_ARGS)
Datum	array_get_element (Datum arraydatum, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
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_element (Datum arraydatum, int nSubscripts, int *indx, Datum dataValue, bool isNull, 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)
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 (ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
void	deconstruct_array_builtin (ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
bool	array_contains_nulls (ArrayType *array)
Datum	array_eq (PG_FUNCTION_ARGS)
Datum	array_ne (PG_FUNCTION_ARGS)
Datum	array_lt (PG_FUNCTION_ARGS)
Datum	array_gt (PG_FUNCTION_ARGS)
Datum	array_le (PG_FUNCTION_ARGS)
Datum	array_ge (PG_FUNCTION_ARGS)
Datum	btarraycmp (PG_FUNCTION_ARGS)
Datum	hash_array (PG_FUNCTION_ARGS)
Datum	hash_array_extended (PG_FUNCTION_ARGS)
static bool	array_contain_compare (AnyArrayType *array1, AnyArrayType *array2, Oid collation, bool matchall, void **fn_extra)
Datum	arrayoverlap (PG_FUNCTION_ARGS)
Datum	arraycontains (PG_FUNCTION_ARGS)
Datum	arraycontained (PG_FUNCTION_ARGS)
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)
void	array_bitmap_copy (bits8 *destbitmap, int destoffset, const bits8 *srcbitmap, int srcoffset, int nitems)
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)
Datum	array_larger (PG_FUNCTION_ARGS)
Datum	array_smaller (PG_FUNCTION_ARGS)
Datum	generate_subscripts (PG_FUNCTION_ARGS)
Datum	generate_subscripts_nodir (PG_FUNCTION_ARGS)
Datum	array_fill_with_lower_bounds (PG_FUNCTION_ARGS)
Datum	array_fill (PG_FUNCTION_ARGS)
Datum	array_unnest (PG_FUNCTION_ARGS)
Datum	array_unnest_support (PG_FUNCTION_ARGS)
Datum	array_remove (PG_FUNCTION_ARGS)
Datum	array_replace (PG_FUNCTION_ARGS)
Datum	width_bucket_array (PG_FUNCTION_ARGS)
Datum	trim_array (PG_FUNCTION_ARGS)

Variables
bool	Array_nulls = true

Macro Definition Documentation

AARR_FREE_IF_COPY

#define AARR_FREE_IF_COPY	(		array,
			n
	)

Value:

    do { \
        if (!VARATT_IS_EXPANDED_HEADER(array)) \
            PG_FREE_IF_COPY(array, n); \
    } while (0)

Definition at line 51 of file arrayfuncs.c.

APPENDCHAR

#define APPENDCHAR

(

ch

)

(*p++ = (ch), *p = '\0')

APPENDSTR

#define APPENDSTR

(

str

)

(strcpy(p, (str)), p += strlen(p))

ASSGN

#define ASSGN   "="

Definition at line 49 of file arrayfuncs.c.

Typedef Documentation

ArrayIteratorData

typedef struct ArrayIteratorData ArrayIteratorData

generate_subscripts_fctx

typedef struct generate_subscripts_fctx generate_subscripts_fctx

Enumeration Type Documentation

ArrayToken

enum ArrayToken

Enumerator
ATOK_LEVEL_START
ATOK_LEVEL_END
ATOK_DELIM
ATOK_ELEM
ATOK_ELEM_NULL
ATOK_ERROR

Definition at line 58 of file arrayfuncs.c.

{
    ATOK_LEVEL_START,
    ATOK_LEVEL_END,
    ATOK_DELIM,
    ATOK_ELEM,
    ATOK_ELEM_NULL,
    ATOK_ERROR,
} ArrayToken;

Function Documentation

accumArrayResult()

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

Definition at line 5351 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 (%d)",
                            (int) 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, 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
	)

Definition at line 5830 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, 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
	)

Definition at line 5551 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 ((Pointer) 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, 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
	)

Definition at line 4967 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(), 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_cardinality()

Datum array_cardinality

(

PG_FUNCTION_ARGS

)

Definition at line 1791 of file arrayfuncs.c.

{
    AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
 
    PG_RETURN_INT32(ArrayGetNItems(AARR_NDIM(v), AARR_DIMS(v)));
}

References AARR_DIMS, AARR_NDIM, ArrayGetNItems(), PG_GETARG_ANY_ARRAY_P, and PG_RETURN_INT32.

array_cmp()

static int array_cmp ( FunctionCallInfo  fcinfo )

static

Definition at line 3986 of file arrayfuncs.c.

{
    LOCAL_FCINFO(locfcinfo, 2);
    AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
    AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
    Oid         collation = PG_GET_COLLATION();
    int         ndims1 = AARR_NDIM(array1);
    int         ndims2 = AARR_NDIM(array2);
    int        *dims1 = AARR_DIMS(array1);
    int        *dims2 = AARR_DIMS(array2);
    int         nitems1 = ArrayGetNItems(ndims1, dims1);
    int         nitems2 = ArrayGetNItems(ndims2, dims2);
    Oid         element_type = AARR_ELEMTYPE(array1);
    int         result = 0;
    TypeCacheEntry *typentry;
    int         typlen;
    bool        typbyval;
    char        typalign;
    int         min_nitems;
    array_iter  it1;
    array_iter  it2;
    int         i;
 
    if (element_type != AARR_ELEMTYPE(array2))
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("cannot compare arrays of different element types")));
 
    /*
     * We arrange to look up the comparison function only once per series of
     * calls, assuming the element type doesn't change underneath us. The
     * typcache is used so that we have no memory leakage when being used as
     * an index support function.
     */
    typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
    if (typentry == NULL ||
        typentry->type_id != element_type)
    {
        typentry = lookup_type_cache(element_type,
                                     TYPECACHE_CMP_PROC_FINFO);
        if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("could not identify a comparison function for type %s",
                            format_type_be(element_type))));
        fcinfo->flinfo->fn_extra = typentry;
    }
    typlen = typentry->typlen;
    typbyval = typentry->typbyval;
    typalign = typentry->typalign;
 
    /*
     * apply the operator to each pair of array elements.
     */
    InitFunctionCallInfoData(*locfcinfo, &typentry->cmp_proc_finfo, 2,
                             collation, NULL, NULL);
 
    /* Loop over source data */
    min_nitems = Min(nitems1, nitems2);
    array_iter_setup(&it1, array1);
    array_iter_setup(&it2, array2);
 
    for (i = 0; i < min_nitems; i++)
    {
        Datum       elt1;
        Datum       elt2;
        bool        isnull1;
        bool        isnull2;
        int32       cmpresult;
 
        /* Get elements, checking for NULL */
        elt1 = array_iter_next(&it1, &isnull1, i, typlen, typbyval, typalign);
        elt2 = array_iter_next(&it2, &isnull2, i, typlen, typbyval, typalign);
 
        /*
         * We consider two NULLs equal; NULL > not-NULL.
         */
        if (isnull1 && isnull2)
            continue;
        if (isnull1)
        {
            /* arg1 is greater than arg2 */
            result = 1;
            break;
        }
        if (isnull2)
        {
            /* arg1 is less than arg2 */
            result = -1;
            break;
        }
 
        /* Compare the pair of elements */
        locfcinfo->args[0].value = elt1;
        locfcinfo->args[0].isnull = false;
        locfcinfo->args[1].value = elt2;
        locfcinfo->args[1].isnull = false;
        cmpresult = DatumGetInt32(FunctionCallInvoke(locfcinfo));
 
        /* We don't expect comparison support functions to return null */
        Assert(!locfcinfo->isnull);
 
        if (cmpresult == 0)
            continue;           /* equal */
 
        if (cmpresult < 0)
        {
            /* arg1 is less than arg2 */
            result = -1;
            break;
        }
        else
        {
            /* arg1 is greater than arg2 */
            result = 1;
            break;
        }
    }
 
    /*
     * If arrays contain same data (up to end of shorter one), apply
     * additional rules to sort by dimensionality.  The relative significance
     * of the different bits of information is historical; mainly we just care
     * that we don't say "equal" for arrays of different dimensionality.
     */
    if (result == 0)
    {
        if (nitems1 != nitems2)
            result = (nitems1 < nitems2) ? -1 : 1;
        else if (ndims1 != ndims2)
            result = (ndims1 < ndims2) ? -1 : 1;
        else
        {
            for (i = 0; i < ndims1; i++)
            {
                if (dims1[i] != dims2[i])
                {
                    result = (dims1[i] < dims2[i]) ? -1 : 1;
                    break;
                }
            }
            if (result == 0)
            {
                int        *lbound1 = AARR_LBOUND(array1);
                int        *lbound2 = AARR_LBOUND(array2);
 
                for (i = 0; i < ndims1; i++)
                {
                    if (lbound1[i] != lbound2[i])
                    {
                        result = (lbound1[i] < lbound2[i]) ? -1 : 1;
                        break;
                    }
                }
            }
        }
    }
 
    /* Avoid leaking memory when handed toasted input. */
    AARR_FREE_IF_COPY(array1, 0);
    AARR_FREE_IF_COPY(array2, 1);
 
    return result;
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_FREE_IF_COPY, AARR_LBOUND, AARR_NDIM, array_iter_next(), array_iter_setup(), ArrayGetNItems(), Assert(), TypeCacheEntry::cmp_proc_finfo, DatumGetInt32(), ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, i, if(), InitFunctionCallInfoData, LOCAL_FCINFO, lookup_type_cache(), Min, OidIsValid, PG_GET_COLLATION, PG_GETARG_ANY_ARRAY_P, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_CMP_PROC_FINFO, and TypeCacheEntry::typlen.

Referenced by array_ge(), array_gt(), array_larger(), array_le(), array_lt(), array_smaller(), and btarraycmp().

array_contain_compare()

static bool array_contain_compare ( AnyArrayType *  array1, AnyArrayType *  array2, Oid  collation, bool  matchall, void **  fn_extra  )

static

Definition at line 4382 of file arrayfuncs.c.

{
    LOCAL_FCINFO(locfcinfo, 2);
    bool        result = matchall;
    Oid         element_type = AARR_ELEMTYPE(array1);
    TypeCacheEntry *typentry;
    int         nelems1;
    Datum      *values2;
    bool       *nulls2;
    int         nelems2;
    int         typlen;
    bool        typbyval;
    char        typalign;
    int         i;
    int         j;
    array_iter  it1;
 
    if (element_type != AARR_ELEMTYPE(array2))
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("cannot compare arrays of different element types")));
 
    /*
     * We arrange to look up the equality function only once per series of
     * calls, assuming the element type doesn't change underneath us.  The
     * typcache is used so that we have no memory leakage when being used as
     * an index support function.
     */
    typentry = (TypeCacheEntry *) *fn_extra;
    if (typentry == NULL ||
        typentry->type_id != element_type)
    {
        typentry = lookup_type_cache(element_type,
                                     TYPECACHE_EQ_OPR_FINFO);
        if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("could not identify an equality operator for type %s",
                            format_type_be(element_type))));
        *fn_extra = typentry;
    }
    typlen = typentry->typlen;
    typbyval = typentry->typbyval;
    typalign = typentry->typalign;
 
    /*
     * Since we probably will need to scan array2 multiple times, it's
     * worthwhile to use deconstruct_array on it.  We scan array1 the hard way
     * however, since we very likely won't need to look at all of it.
     */
    if (VARATT_IS_EXPANDED_HEADER(array2))
    {
        /* This should be safe even if input is read-only */
        deconstruct_expanded_array(&(array2->xpn));
        values2 = array2->xpn.dvalues;
        nulls2 = array2->xpn.dnulls;
        nelems2 = array2->xpn.nelems;
    }
    else
        deconstruct_array((ArrayType *) array2,
                          element_type, typlen, typbyval, typalign,
                          &values2, &nulls2, &nelems2);
 
    /*
     * Apply the comparison operator to each pair of array elements.
     */
    InitFunctionCallInfoData(*locfcinfo, &typentry->eq_opr_finfo, 2,
                             collation, NULL, NULL);
 
    /* Loop over source data */
    nelems1 = ArrayGetNItems(AARR_NDIM(array1), AARR_DIMS(array1));
    array_iter_setup(&it1, array1);
 
    for (i = 0; i < nelems1; i++)
    {
        Datum       elt1;
        bool        isnull1;
 
        /* Get element, checking for NULL */
        elt1 = array_iter_next(&it1, &isnull1, i, typlen, typbyval, typalign);
 
        /*
         * We assume that the comparison operator is strict, so a NULL can't
         * match anything.  XXX this diverges from the "NULL=NULL" behavior of
         * array_eq, should we act like that?
         */
        if (isnull1)
        {
            if (matchall)
            {
                result = false;
                break;
            }
            continue;
        }
 
        for (j = 0; j < nelems2; j++)
        {
            Datum       elt2 = values2[j];
            bool        isnull2 = nulls2 ? nulls2[j] : false;
            bool        oprresult;
 
            if (isnull2)
                continue;       /* can't match */
 
            /*
             * Apply the operator to the element pair; treat NULL as false
             */
            locfcinfo->args[0].value = elt1;
            locfcinfo->args[0].isnull = false;
            locfcinfo->args[1].value = elt2;
            locfcinfo->args[1].isnull = false;
            locfcinfo->isnull = false;
            oprresult = DatumGetBool(FunctionCallInvoke(locfcinfo));
            if (!locfcinfo->isnull && oprresult)
                break;
        }
 
        if (j < nelems2)
        {
            /* found a match for elt1 */
            if (!matchall)
            {
                result = true;
                break;
            }
        }
        else
        {
            /* no match for elt1 */
            if (matchall)
            {
                result = false;
                break;
            }
        }
    }
 
    return result;
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_NDIM, array_iter_next(), array_iter_setup(), ArrayGetNItems(), DatumGetBool(), deconstruct_array(), deconstruct_expanded_array(), ExpandedArrayHeader::dnulls, ExpandedArrayHeader::dvalues, TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, i, InitFunctionCallInfoData, j, LOCAL_FCINFO, lookup_type_cache(), ExpandedArrayHeader::nelems, OidIsValid, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_EQ_OPR_FINFO, TypeCacheEntry::typlen, VARATT_IS_EXPANDED_HEADER, and AnyArrayType::xpn.

Referenced by arraycontained(), arraycontains(), and arrayoverlap().

array_contains_nulls()

bool array_contains_nulls

(

ArrayType *

array

)

Definition at line 3768 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(), 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(), stats_check_arg_array(), text_to_stavalues(), width_bucket_array(), and worker_spi_launch().

array_copy()

static int array_copy ( char *  destptr, int  nitems, char *  srcptr, int  offset, bits8 *  nullbitmap, int  typlen, bool  typbyval, char  typalign  )

static

Definition at line 4937 of file arrayfuncs.c.

{
    int         numbytes;
 
    numbytes = array_nelems_size(srcptr, offset, nullbitmap, nitems,
                                 typlen, typbyval, typalign);
    memcpy(destptr, srcptr, numbytes);
    return numbytes;
}

References array_nelems_size(), nitems, and typalign.

Referenced by array_extract_slice(), and array_insert_slice().

array_create_iterator()

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

Definition at line 4598 of file arrayfuncs.c.

{
    ArrayIterator iterator = palloc0(sizeof(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);
 
    /*
     * 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 ArrayIteratorData::arr, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), Assert(), ArrayIteratorData::current_item, ArrayIteratorData::data_ptr, ArrayMetaState::element_type, elog, ERROR, get_typlenbyvalalign(), ArrayIteratorData::nitems, ArrayIteratorData::nullbitmap, palloc(), palloc0(), ArrayIteratorData::slice_dims, ArrayIteratorData::slice_lbound, ArrayIteratorData::slice_len, ArrayIteratorData::slice_ndim, ArrayIteratorData::slice_nulls, ArrayIteratorData::slice_values, ArrayIteratorData::typalign, ArrayMetaState::typalign, ArrayIteratorData::typbyval, ArrayMetaState::typbyval, ArrayIteratorData::typlen, and ArrayMetaState::typlen.

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

array_dims()

Datum array_dims

(

PG_FUNCTION_ARGS

)

Definition at line 1669 of file arrayfuncs.c.

{
    AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
    char       *p;
    int         i;
    int        *dimv,
               *lb;
 
    /*
     * 33 since we assume 15 digits per number + ':' +'[]'
     *
     * +1 for trailing null
     */
    char        buf[MAXDIM * 33 + 1];
 
    /* Sanity check: does it look like an array at all? */
    if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
        PG_RETURN_NULL();
 
    dimv = AARR_DIMS(v);
    lb = AARR_LBOUND(v);
 
    p = buf;
    for (i = 0; i < AARR_NDIM(v); i++)
    {
        sprintf(p, "[%d:%d]", lb[i], dimv[i] + lb[i] - 1);
        p += strlen(p);
    }
 
    PG_RETURN_TEXT_P(cstring_to_text(buf));
}

References AARR_DIMS, AARR_LBOUND, AARR_NDIM, buf, cstring_to_text(), i, MAXDIM, PG_GETARG_ANY_ARRAY_P, PG_RETURN_NULL, PG_RETURN_TEXT_P, and sprintf.

array_eq()

Datum array_eq

(

PG_FUNCTION_ARGS

)

Definition at line 3815 of file arrayfuncs.c.

{
    LOCAL_FCINFO(locfcinfo, 2);
    AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
    AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
    Oid         collation = PG_GET_COLLATION();
    int         ndims1 = AARR_NDIM(array1);
    int         ndims2 = AARR_NDIM(array2);
    int        *dims1 = AARR_DIMS(array1);
    int        *dims2 = AARR_DIMS(array2);
    int        *lbs1 = AARR_LBOUND(array1);
    int        *lbs2 = AARR_LBOUND(array2);
    Oid         element_type = AARR_ELEMTYPE(array1);
    bool        result = true;
    int         nitems;
    TypeCacheEntry *typentry;
    int         typlen;
    bool        typbyval;
    char        typalign;
    array_iter  it1;
    array_iter  it2;
    int         i;
 
    if (element_type != AARR_ELEMTYPE(array2))
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("cannot compare arrays of different element types")));
 
    /* fast path if the arrays do not have the same dimensionality */
    if (ndims1 != ndims2 ||
        memcmp(dims1, dims2, ndims1 * sizeof(int)) != 0 ||
        memcmp(lbs1, lbs2, ndims1 * sizeof(int)) != 0)
        result = false;
    else
    {
        /*
         * We arrange to look up the equality function only once per series of
         * calls, assuming the element type doesn't change underneath us.  The
         * typcache is used so that we have no memory leakage when being used
         * as an index support function.
         */
        typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
        if (typentry == NULL ||
            typentry->type_id != element_type)
        {
            typentry = lookup_type_cache(element_type,
                                         TYPECACHE_EQ_OPR_FINFO);
            if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("could not identify an equality operator for type %s",
                                format_type_be(element_type))));
            fcinfo->flinfo->fn_extra = typentry;
        }
        typlen = typentry->typlen;
        typbyval = typentry->typbyval;
        typalign = typentry->typalign;
 
        /*
         * apply the operator to each pair of array elements.
         */
        InitFunctionCallInfoData(*locfcinfo, &typentry->eq_opr_finfo, 2,
                                 collation, NULL, NULL);
 
        /* Loop over source data */
        nitems = ArrayGetNItems(ndims1, dims1);
        array_iter_setup(&it1, array1);
        array_iter_setup(&it2, array2);
 
        for (i = 0; i < nitems; i++)
        {
            Datum       elt1;
            Datum       elt2;
            bool        isnull1;
            bool        isnull2;
            bool        oprresult;
 
            /* Get elements, checking for NULL */
            elt1 = array_iter_next(&it1, &isnull1, i,
                                   typlen, typbyval, typalign);
            elt2 = array_iter_next(&it2, &isnull2, i,
                                   typlen, typbyval, typalign);
 
            /*
             * We consider two NULLs equal; NULL and not-NULL are unequal.
             */
            if (isnull1 && isnull2)
                continue;
            if (isnull1 || isnull2)
            {
                result = false;
                break;
            }
 
            /*
             * Apply the operator to the element pair; treat NULL as false
             */
            locfcinfo->args[0].value = elt1;
            locfcinfo->args[0].isnull = false;
            locfcinfo->args[1].value = elt2;
            locfcinfo->args[1].isnull = false;
            locfcinfo->isnull = false;
            oprresult = DatumGetBool(FunctionCallInvoke(locfcinfo));
            if (locfcinfo->isnull || !oprresult)
            {
                result = false;
                break;
            }
        }
    }
 
    /* Avoid leaking memory when handed toasted input. */
    AARR_FREE_IF_COPY(array1, 0);
    AARR_FREE_IF_COPY(array2, 1);
 
    PG_RETURN_BOOL(result);
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_FREE_IF_COPY, AARR_LBOUND, AARR_NDIM, array_iter_next(), array_iter_setup(), ArrayGetNItems(), DatumGetBool(), TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, i, if(), InitFunctionCallInfoData, LOCAL_FCINFO, lookup_type_cache(), nitems, OidIsValid, PG_GET_COLLATION, PG_GETARG_ANY_ARRAY_P, PG_RETURN_BOOL, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_EQ_OPR_FINFO, and TypeCacheEntry::typlen.

Referenced by array_ne().

array_extract_slice()

static void array_extract_slice ( ArrayType *  newarray, int  ndim, int *  dim, int *  lb, char *  arraydataptr, bits8 *  arraynullsptr, int *  st, int *  endp, int  typlen, bool  typbyval, char  typalign  )

static

Definition at line 5098 of file arrayfuncs.c.

{
    char       *destdataptr = ARR_DATA_PTR(newarray);
    bits8      *destnullsptr = ARR_NULLBITMAP(newarray);
    char       *srcdataptr;
    int         src_offset,
                dest_offset,
                prod[MAXDIM],
                span[MAXDIM],
                dist[MAXDIM],
                indx[MAXDIM];
    int         i,
                j,
                inc;
 
    src_offset = ArrayGetOffset(ndim, dim, lb, st);
    srcdataptr = array_seek(arraydataptr, 0, arraynullsptr, src_offset,
                            typlen, typbyval, typalign);
    mda_get_prod(ndim, dim, prod);
    mda_get_range(ndim, span, st, endp);
    mda_get_offset_values(ndim, dist, prod, span);
    for (i = 0; i < ndim; i++)
        indx[i] = 0;
    dest_offset = 0;
    j = ndim - 1;
    do
    {
        if (dist[j])
        {
            /* skip unwanted elements */
            srcdataptr = array_seek(srcdataptr, src_offset, arraynullsptr,
                                    dist[j],
                                    typlen, typbyval, typalign);
            src_offset += dist[j];
        }
        inc = array_copy(destdataptr, 1,
                         srcdataptr, src_offset, arraynullsptr,
                         typlen, typbyval, typalign);
        if (destnullsptr)
            array_bitmap_copy(destnullsptr, dest_offset,
                              arraynullsptr, src_offset,
                              1);
        destdataptr += inc;
        srcdataptr += inc;
        src_offset++;
        dest_offset++;
    } while ((j = mda_next_tuple(ndim, indx, span)) != -1);
}

References ARR_DATA_PTR, ARR_NULLBITMAP, array_bitmap_copy(), array_copy(), array_seek(), ArrayGetOffset(), i, j, MAXDIM, mda_get_offset_values(), mda_get_prod(), mda_get_range(), mda_next_tuple(), and typalign.

Referenced by array_get_slice().

array_fill()

Datum array_fill

(

PG_FUNCTION_ARGS

)

Definition at line 6034 of file arrayfuncs.c.

{
    ArrayType  *dims;
    ArrayType  *result;
    Oid         elmtype;
    Datum       value;
    bool        isnull;
 
    if (PG_ARGISNULL(1))
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("dimension array or low bound array cannot be null")));
 
    dims = PG_GETARG_ARRAYTYPE_P(1);
 
    if (!PG_ARGISNULL(0))
    {
        value = PG_GETARG_DATUM(0);
        isnull = false;
    }
    else
    {
        value = 0;
        isnull = true;
    }
 
    elmtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
    if (!OidIsValid(elmtype))
        elog(ERROR, "could not determine data type of input");
 
    result = array_fill_internal(dims, NULL, value, isnull, elmtype, fcinfo);
    PG_RETURN_ARRAYTYPE_P(result);
}

References array_fill_internal(), elog, ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), OidIsValid, PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_RETURN_ARRAYTYPE_P, and value.

array_fill_internal()

static ArrayType * array_fill_internal ( ArrayType *  dims, ArrayType *  lbs, Datum  value, bool  isnull, Oid  elmtype, FunctionCallInfo  fcinfo  )

static

Definition at line 6086 of file arrayfuncs.c.

{
    ArrayType  *result;
    int        *dimv;
    int        *lbsv;
    int         ndims;
    int         nitems;
    int         deflbs[MAXDIM];
    int16       elmlen;
    bool        elmbyval;
    char        elmalign;
    ArrayMetaState *my_extra;
 
    /*
     * Params checks
     */
    if (ARR_NDIM(dims) > 1)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("wrong number of array subscripts"),
                 errdetail("Dimension array must be one dimensional.")));
 
    if (array_contains_nulls(dims))
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("dimension values cannot be null")));
 
    dimv = (int *) ARR_DATA_PTR(dims);
    ndims = (ARR_NDIM(dims) > 0) ? ARR_DIMS(dims)[0] : 0;
 
    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)));
 
    if (lbs != NULL)
    {
        if (ARR_NDIM(lbs) > 1)
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("wrong number of array subscripts"),
                     errdetail("Dimension array must be one dimensional.")));
 
        if (array_contains_nulls(lbs))
            ereport(ERROR,
                    (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                     errmsg("dimension values cannot be null")));
 
        if (ndims != ((ARR_NDIM(lbs) > 0) ? ARR_DIMS(lbs)[0] : 0))
            ereport(ERROR,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("wrong number of array subscripts"),
                     errdetail("Low bound array has different size than dimensions array.")));
 
        lbsv = (int *) ARR_DATA_PTR(lbs);
    }
    else
    {
        int         i;
 
        for (i = 0; i < MAXDIM; i++)
            deflbs[i] = 1;
 
        lbsv = deflbs;
    }
 
    /* This checks for overflow of the array dimensions */
    nitems = ArrayGetNItems(ndims, dimv);
    ArrayCheckBounds(ndims, dimv, lbsv);
 
    /* fast track for empty array */
    if (nitems <= 0)
        return construct_empty_array(elmtype);
 
    /*
     * We arrange to look up info about element type only once per series of
     * calls, assuming the element type doesn't change underneath us.
     */
    my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL)
    {
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(ArrayMetaState));
        my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
        my_extra->element_type = InvalidOid;
    }
 
    if (my_extra->element_type != elmtype)
    {
        /* Get info about element type */
        get_typlenbyvalalign(elmtype,
                             &my_extra->typlen,
                             &my_extra->typbyval,
                             &my_extra->typalign);
        my_extra->element_type = elmtype;
    }
 
    elmlen = my_extra->typlen;
    elmbyval = my_extra->typbyval;
    elmalign = my_extra->typalign;
 
    /* compute required space */
    if (!isnull)
    {
        int         i;
        char       *p;
        int         nbytes;
        int         totbytes;
 
        /* make sure data is not toasted */
        if (elmlen == -1)
            value = PointerGetDatum(PG_DETOAST_DATUM(value));
 
        nbytes = att_addlength_datum(0, elmlen, value);
        nbytes = att_align_nominal(nbytes, elmalign);
        Assert(nbytes > 0);
 
        totbytes = nbytes * nitems;
 
        /* check for overflow of multiplication or total request */
        if (totbytes / nbytes != nitems ||
            !AllocSizeIsValid(totbytes))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array size exceeds the maximum allowed (%d)",
                            (int) MaxAllocSize)));
 
        /*
         * This addition can't overflow, but it might cause us to go past
         * MaxAllocSize.  We leave it to palloc to complain in that case.
         */
        totbytes += ARR_OVERHEAD_NONULLS(ndims);
 
        result = create_array_envelope(ndims, dimv, lbsv, totbytes,
                                       elmtype, 0);
 
        p = ARR_DATA_PTR(result);
        for (i = 0; i < nitems; i++)
            p += ArrayCastAndSet(value, elmlen, elmbyval, elmalign, p);
    }
    else
    {
        int         nbytes;
        int         dataoffset;
 
        dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
        nbytes = dataoffset;
 
        result = create_array_envelope(ndims, dimv, lbsv, nbytes,
                                       elmtype, dataoffset);
 
        /* create_array_envelope already zeroed the bitmap, so we're done */
    }
 
    return result;
}

References AllocSizeIsValid, ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, array_contains_nulls(), ArrayCastAndSet(), ArrayCheckBounds(), ArrayGetNItems(), Assert(), att_addlength_datum, att_align_nominal, construct_empty_array(), create_array_envelope(), ArrayMetaState::element_type, ereport, errcode(), errdetail(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, get_typlenbyvalalign(), i, if(), InvalidOid, MaxAllocSize, MAXDIM, MemoryContextAlloc(), nitems, PG_DETOAST_DATUM, PointerGetDatum(), ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typlen, and value.

Referenced by array_fill(), and array_fill_with_lower_bounds().

array_fill_with_lower_bounds()

Datum array_fill_with_lower_bounds

(

PG_FUNCTION_ARGS

)

Definition at line 5993 of file arrayfuncs.c.

{
    ArrayType  *dims;
    ArrayType  *lbs;
    ArrayType  *result;
    Oid         elmtype;
    Datum       value;
    bool        isnull;
 
    if (PG_ARGISNULL(1) || PG_ARGISNULL(2))
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("dimension array or low bound array cannot be null")));
 
    dims = PG_GETARG_ARRAYTYPE_P(1);
    lbs = PG_GETARG_ARRAYTYPE_P(2);
 
    if (!PG_ARGISNULL(0))
    {
        value = PG_GETARG_DATUM(0);
        isnull = false;
    }
    else
    {
        value = 0;
        isnull = true;
    }
 
    elmtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
    if (!OidIsValid(elmtype))
        elog(ERROR, "could not determine data type of input");
 
    result = array_fill_internal(dims, lbs, value, isnull, elmtype, fcinfo);
    PG_RETURN_ARRAYTYPE_P(result);
}

References array_fill_internal(), elog, ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), OidIsValid, PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_RETURN_ARRAYTYPE_P, and value.

array_free_iterator()

void array_free_iterator

(

ArrayIterator

iterator

)

Definition at line 4760 of file arrayfuncs.c.

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

References pfree(), ArrayIteratorData::slice_ndim, ArrayIteratorData::slice_nulls, and ArrayIteratorData::slice_values.

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

array_ge()

Datum array_ge

(

PG_FUNCTION_ARGS

)

Definition at line 3968 of file arrayfuncs.c.

{
    PG_RETURN_BOOL(array_cmp(fcinfo) >= 0);
}

References array_cmp(), and PG_RETURN_BOOL.

array_get_element()

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

Definition at line 1821 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(), i, MAXDIM, and VARATT_IS_EXTERNAL_EXPANDED().

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

array_get_element_expanded()

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

static

Definition at line 1922 of file arrayfuncs.c.

{
    ExpandedArrayHeader *eah;
    int         i,
                ndim,
               *dim,
               *lb,
                offset;
    Datum      *dvalues;
    bool       *dnulls;
 
    eah = (ExpandedArrayHeader *) DatumGetEOHP(arraydatum);
    Assert(eah->ea_magic == EA_MAGIC);
 
    /* sanity-check caller's info against object */
    Assert(arraytyplen == -1);
    Assert(elmlen == eah->typlen);
    Assert(elmbyval == eah->typbyval);
    Assert(elmalign == eah->typalign);
 
    ndim = eah->ndims;
    dim = eah->dims;
    lb = eah->lbound;
 
    /*
     * 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);
 
    /*
     * Deconstruct array if we didn't already.  Note that we apply this even
     * if the input is nominally read-only: it should be safe enough.
     */
    deconstruct_expanded_array(eah);
 
    dvalues = eah->dvalues;
    dnulls = eah->dnulls;
 
    /*
     * Check for NULL array element
     */
    if (dnulls && dnulls[offset])
    {
        *isNull = true;
        return (Datum) 0;
    }
 
    /*
     * OK, get the element.  It's OK to return a pass-by-ref value as a
     * pointer into the expanded array, for the same reason that regular
     * array_get_element can return a pointer into flat arrays: the value is
     * assumed not to change for as long as the Datum reference can exist.
     */
    *isNull = false;
    return dvalues[offset];
}

References ArrayGetOffset(), Assert(), DatumGetEOHP(), deconstruct_expanded_array(), ExpandedArrayHeader::dims, ExpandedArrayHeader::dnulls, ExpandedArrayHeader::dvalues, EA_MAGIC, ExpandedArrayHeader::ea_magic, i, ExpandedArrayHeader::lbound, MAXDIM, ExpandedArrayHeader::ndims, ExpandedArrayHeader::typalign, ExpandedArrayHeader::typbyval, and ExpandedArrayHeader::typlen.

Referenced by array_get_element().

array_get_isnull()

static bool array_get_isnull ( const bits8 *  nullbitmap, int  offset  )

static

Definition at line 4782 of file arrayfuncs.c.

{
    if (nullbitmap == NULL)
        return false;           /* assume not null */
    if (nullbitmap[offset / 8] & (1 << (offset % 8)))
        return false;           /* not null */
    return true;
}

Referenced by array_get_element(), array_iterate(), array_set_element(), and array_slice_size().

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
	)

Definition at line 2031 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(), ArrayType::dataoffset, DatumGetArrayTypeP, DatumGetPointer(), ArrayType::elemtype, ereport, errcode(), errmsg(), ERROR, i, InvalidOid, MAXDIM, mda_get_range(), ArrayType::ndim, palloc0(), PointerGetDatum(), and SET_VARSIZE().

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

array_gt()

Datum array_gt

(

PG_FUNCTION_ARGS

)

Definition at line 3956 of file arrayfuncs.c.

{
    PG_RETURN_BOOL(array_cmp(fcinfo) > 0);
}

References array_cmp(), and PG_RETURN_BOOL.

array_in()

Datum array_in

(

PG_FUNCTION_ARGS

)

Definition at line 180 of file arrayfuncs.c.

{
    char       *string = PG_GETARG_CSTRING(0);  /* external form */
    Oid         element_type = PG_GETARG_OID(1);    /* type of an array
                                                     * element */
    int32       typmod = PG_GETARG_INT32(2);    /* typmod for array elements */
    Node       *escontext = fcinfo->context;
    int         typlen;
    bool        typbyval;
    char        typalign;
    char        typdelim;
    Oid         typioparam;
    char       *p;
    int         nitems;
    Datum      *values;
    bool       *nulls;
    bool        hasnulls;
    int32       nbytes;
    int32       dataoffset;
    ArrayType  *retval;
    int         ndim,
                dim[MAXDIM],
                lBound[MAXDIM];
    ArrayMetaState *my_extra;
 
    /*
     * We arrange to look up info about element type, including its input
     * conversion proc, only once per series of calls, assuming the element
     * type doesn't change underneath us.
     */
    my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL)
    {
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(ArrayMetaState));
        my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
        my_extra->element_type = ~element_type;
    }
 
    if (my_extra->element_type != element_type)
    {
        /*
         * Get info about element type, including its input conversion proc
         */
        get_type_io_data(element_type, IOFunc_input,
                         &my_extra->typlen, &my_extra->typbyval,
                         &my_extra->typalign, &my_extra->typdelim,
                         &my_extra->typioparam, &my_extra->typiofunc);
        fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
                      fcinfo->flinfo->fn_mcxt);
        my_extra->element_type = element_type;
    }
    typlen = my_extra->typlen;
    typbyval = my_extra->typbyval;
    typalign = my_extra->typalign;
    typdelim = my_extra->typdelim;
    typioparam = my_extra->typioparam;
 
    /*
     * Initialize dim[] and lBound[] for ReadArrayStr, in case there is no
     * explicit dimension info.  (If there is, ReadArrayDimensions will
     * overwrite this.)
     */
    for (int i = 0; i < MAXDIM; i++)
    {
        dim[i] = -1;            /* indicates "not yet known" */
        lBound[i] = 1;          /* default lower bound */
    }
 
    /*
     * Start processing the input string.
     *
     * If the input string starts with dimension info, read and use that.
     * Otherwise, we'll determine the dimensions during ReadArrayStr.
     */
    p = string;
    if (!ReadArrayDimensions(&p, &ndim, dim, lBound, string, escontext))
        return (Datum) 0;
 
    if (ndim == 0)
    {
        /* No array dimensions, so next character should be a left brace */
        if (*p != '{')
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", string),
                     errdetail("Array value must start with \"{\" or dimension information.")));
    }
    else
    {
        /* If array dimensions are given, expect '=' operator */
        if (strncmp(p, ASSGN, strlen(ASSGN)) != 0)
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", string),
                     errdetail("Missing \"%s\" after array dimensions.",
                               ASSGN)));
        p += strlen(ASSGN);
        /* Allow whitespace after it */
        while (scanner_isspace(*p))
            p++;
 
        if (*p != '{')
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", string),
                     errdetail("Array contents must start with \"{\".")));
    }
 
    /* Parse the value part, in the curly braces: { ... } */
    if (!ReadArrayStr(&p,
                      &my_extra->proc, typioparam, typmod,
                      typdelim,
                      typlen, typbyval, typalign,
                      &ndim,
                      dim,
                      &nitems,
                      &values, &nulls,
                      string,
                      escontext))
        return (Datum) 0;
 
    /* only whitespace is allowed after the closing brace */
    while (*p)
    {
        if (!scanner_isspace(*p++))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", string),
                     errdetail("Junk after closing right brace.")));
    }
 
    /* Empty array? */
    if (nitems == 0)
        PG_RETURN_ARRAYTYPE_P(construct_empty_array(element_type));
 
    /*
     * Check for nulls, compute total data space needed
     */
    hasnulls = false;
    nbytes = 0;
    for (int i = 0; i < nitems; i++)
    {
        if (nulls[i])
            hasnulls = true;
        else
        {
            /* let's just make sure data is not toasted */
            if (typlen == -1)
                values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
            nbytes = att_addlength_datum(nbytes, typlen, values[i]);
            nbytes = att_align_nominal(nbytes, typalign);
            /* check for overflow of total request */
            if (!AllocSizeIsValid(nbytes))
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%d)",
                                (int) MaxAllocSize)));
        }
    }
    if (hasnulls)
    {
        dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
        nbytes += dataoffset;
    }
    else
    {
        dataoffset = 0;         /* marker for no null bitmap */
        nbytes += ARR_OVERHEAD_NONULLS(ndim);
    }
 
    /*
     * Construct the final array datum
     */
    retval = (ArrayType *) palloc0(nbytes);
    SET_VARSIZE(retval, nbytes);
    retval->ndim = ndim;
    retval->dataoffset = dataoffset;
 
    /*
     * This comes from the array's pg_type.typelem (which points to the base
     * data type's pg_type.oid) and stores system oids in user tables. This
     * oid must be preserved by binary upgrades.
     */
    retval->elemtype = element_type;
    memcpy(ARR_DIMS(retval), dim, ndim * sizeof(int));
    memcpy(ARR_LBOUND(retval), lBound, ndim * sizeof(int));
 
    CopyArrayEls(retval,
                 values, nulls, nitems,
                 typlen, typbyval, typalign,
                 true);
 
    pfree(values);
    pfree(nulls);
 
    PG_RETURN_ARRAYTYPE_P(retval);
}

References AllocSizeIsValid, ARR_DIMS, ARR_LBOUND, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ASSGN, att_addlength_datum, att_align_nominal, construct_empty_array(), CopyArrayEls(), ArrayType::dataoffset, ArrayMetaState::element_type, ArrayType::elemtype, ereturn, errcode(), errdetail(), errmsg(), fmgr_info_cxt(), FmgrInfo::fn_mcxt, get_type_io_data(), i, if(), IOFunc_input, MaxAllocSize, MAXDIM, MemoryContextAlloc(), ArrayType::ndim, nitems, palloc0(), pfree(), PG_DETOAST_DATUM, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_ARRAYTYPE_P, PointerGetDatum(), ArrayMetaState::proc, ReadArrayDimensions(), ReadArrayStr(), scanner_isspace(), SET_VARSIZE(), typalign, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, ArrayMetaState::typlen, and values.

Referenced by extract_variadic_args(), and text_to_stavalues().

array_insert_slice()

static void array_insert_slice ( ArrayType *  destArray, ArrayType *  origArray, ArrayType *  srcArray, int  ndim, int *  dim, int *  lb, int *  st, int *  endp, int  typlen, bool  typbyval, char  typalign  )

static

Definition at line 5171 of file arrayfuncs.c.

{
    char       *destPtr = ARR_DATA_PTR(destArray);
    char       *origPtr = ARR_DATA_PTR(origArray);
    char       *srcPtr = ARR_DATA_PTR(srcArray);
    bits8      *destBitmap = ARR_NULLBITMAP(destArray);
    bits8      *origBitmap = ARR_NULLBITMAP(origArray);
    bits8      *srcBitmap = ARR_NULLBITMAP(srcArray);
    int         orignitems = ArrayGetNItems(ARR_NDIM(origArray),
                                            ARR_DIMS(origArray));
    int         dest_offset,
                orig_offset,
                src_offset,
                prod[MAXDIM],
                span[MAXDIM],
                dist[MAXDIM],
                indx[MAXDIM];
    int         i,
                j,
                inc;
 
    dest_offset = ArrayGetOffset(ndim, dim, lb, st);
    /* copy items before the slice start */
    inc = array_copy(destPtr, dest_offset,
                     origPtr, 0, origBitmap,
                     typlen, typbyval, typalign);
    destPtr += inc;
    origPtr += inc;
    if (destBitmap)
        array_bitmap_copy(destBitmap, 0, origBitmap, 0, dest_offset);
    orig_offset = dest_offset;
    mda_get_prod(ndim, dim, prod);
    mda_get_range(ndim, span, st, endp);
    mda_get_offset_values(ndim, dist, prod, span);
    for (i = 0; i < ndim; i++)
        indx[i] = 0;
    src_offset = 0;
    j = ndim - 1;
    do
    {
        /* Copy/advance over elements between here and next part of slice */
        if (dist[j])
        {
            inc = array_copy(destPtr, dist[j],
                             origPtr, orig_offset, origBitmap,
                             typlen, typbyval, typalign);
            destPtr += inc;
            origPtr += inc;
            if (destBitmap)
                array_bitmap_copy(destBitmap, dest_offset,
                                  origBitmap, orig_offset,
                                  dist[j]);
            dest_offset += dist[j];
            orig_offset += dist[j];
        }
        /* Copy new element at this slice position */
        inc = array_copy(destPtr, 1,
                         srcPtr, src_offset, srcBitmap,
                         typlen, typbyval, typalign);
        if (destBitmap)
            array_bitmap_copy(destBitmap, dest_offset,
                              srcBitmap, src_offset,
                              1);
        destPtr += inc;
        srcPtr += inc;
        dest_offset++;
        src_offset++;
        /* Advance over old element at this slice position */
        origPtr = array_seek(origPtr, orig_offset, origBitmap, 1,
                             typlen, typbyval, typalign);
        orig_offset++;
    } while ((j = mda_next_tuple(ndim, indx, span)) != -1);
 
    /* don't miss any data at the end */
    array_copy(destPtr, orignitems - orig_offset,
               origPtr, orig_offset, origBitmap,
               typlen, typbyval, typalign);
    if (destBitmap)
        array_bitmap_copy(destBitmap, dest_offset,
                          origBitmap, orig_offset,
                          orignitems - orig_offset);
}

References ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, ARR_NULLBITMAP, array_bitmap_copy(), array_copy(), array_seek(), ArrayGetNItems(), ArrayGetOffset(), i, j, MAXDIM, mda_get_offset_values(), mda_get_prod(), mda_get_range(), mda_next_tuple(), and typalign.

Referenced by array_set_slice().

array_iterate()

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

Definition at line 4677 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_align_nominal(p, iterator->typalign);
            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_align_nominal(p, iterator->typalign);
            }
        }
 
        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 ArrayIteratorData::arr, ARR_ELEMTYPE, array_get_isnull(), att_addlength_pointer, att_align_nominal, construct_md_array(), ArrayIteratorData::current_item, ArrayIteratorData::data_ptr, fetch_att(), i, ArrayIteratorData::nitems, ArrayIteratorData::nullbitmap, PointerGetDatum(), ArrayIteratorData::slice_dims, ArrayIteratorData::slice_lbound, ArrayIteratorData::slice_len, ArrayIteratorData::slice_ndim, ArrayIteratorData::slice_nulls, ArrayIteratorData::slice_values, ArrayIteratorData::typalign, ArrayIteratorData::typbyval, ArrayIteratorData::typlen, value, and values.

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

array_larger()

Datum array_larger

(

PG_FUNCTION_ARGS

)

Definition at line 5888 of file arrayfuncs.c.

{
    if (array_cmp(fcinfo) > 0)
        PG_RETURN_DATUM(PG_GETARG_DATUM(0));
    else
        PG_RETURN_DATUM(PG_GETARG_DATUM(1));
}

References array_cmp(), PG_GETARG_DATUM, and PG_RETURN_DATUM.

array_le()

Datum array_le

(

PG_FUNCTION_ARGS

)

Definition at line 3962 of file arrayfuncs.c.

{
    PG_RETURN_BOOL(array_cmp(fcinfo) <= 0);
}

References array_cmp(), and PG_RETURN_BOOL.

array_length()

Datum array_length

(

PG_FUNCTION_ARGS

)

Definition at line 1764 of file arrayfuncs.c.

{
    AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
    int         reqdim = PG_GETARG_INT32(1);
    int        *dimv;
    int         result;
 
    /* Sanity check: does it look like an array at all? */
    if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
        PG_RETURN_NULL();
 
    /* Sanity check: was the requested dim valid */
    if (reqdim <= 0 || reqdim > AARR_NDIM(v))
        PG_RETURN_NULL();
 
    dimv = AARR_DIMS(v);
 
    result = dimv[reqdim - 1];
 
    PG_RETURN_INT32(result);
}

References AARR_DIMS, AARR_NDIM, MAXDIM, PG_GETARG_ANY_ARRAY_P, PG_GETARG_INT32, PG_RETURN_INT32, and PG_RETURN_NULL.

Referenced by trim_array().

array_lower()

Datum array_lower

(

PG_FUNCTION_ARGS

)

Definition at line 1707 of file arrayfuncs.c.

{
    AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
    int         reqdim = PG_GETARG_INT32(1);
    int        *lb;
    int         result;
 
    /* Sanity check: does it look like an array at all? */
    if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
        PG_RETURN_NULL();
 
    /* Sanity check: was the requested dim valid */
    if (reqdim <= 0 || reqdim > AARR_NDIM(v))
        PG_RETURN_NULL();
 
    lb = AARR_LBOUND(v);
    result = lb[reqdim - 1];
 
    PG_RETURN_INT32(result);
}

References AARR_LBOUND, AARR_NDIM, MAXDIM, PG_GETARG_ANY_ARRAY_P, PG_GETARG_INT32, PG_RETURN_INT32, and PG_RETURN_NULL.

array_lt()

Datum array_lt

(

PG_FUNCTION_ARGS

)

Definition at line 3950 of file arrayfuncs.c.

{
    PG_RETURN_BOOL(array_cmp(fcinfo) < 0);
}

References array_cmp(), and PG_RETURN_BOOL.

array_map()

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

Definition at line 3202 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;
    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;
 
    /* 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);
    hasnulls = false;
 
    for (i = 0; i < nitems; i++)
    {
        /* Get source element, checking for NULL */
        *transform_source =
            array_iter_next(&iter, transform_source_isnull, i,
                            inp_typlen, inp_typbyval, inp_typalign);
 
        /* 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_align_nominal(nbytes, typalign);
            /* check for overflow of total request */
            if (!AllocSizeIsValid(nbytes))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%d)",
                                (int) 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_align_nominal, construct_empty_array(), CopyArrayEls(), ArrayType::dataoffset, DatumGetAnyArrayP(), ArrayMetaState::element_type, ArrayType::elemtype, ereport, errcode(), errmsg(), ERROR, ExecEvalExpr(), 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, ArrayMetaState::typbyval, ArrayMetaState::typlen, and values.

Referenced by ExecEvalArrayCoerce().

array_ndims()

Datum array_ndims

(

PG_FUNCTION_ARGS

)

Definition at line 1653 of file arrayfuncs.c.

{
    AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
 
    /* Sanity check: does it look like an array at all? */
    if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
        PG_RETURN_NULL();
 
    PG_RETURN_INT32(AARR_NDIM(v));
}

References AARR_NDIM, MAXDIM, PG_GETARG_ANY_ARRAY_P, PG_RETURN_INT32, and PG_RETURN_NULL.

array_ne()

Datum array_ne

(

PG_FUNCTION_ARGS

)

Definition at line 3944 of file arrayfuncs.c.

{
    PG_RETURN_BOOL(!DatumGetBool(array_eq(fcinfo)));
}

References array_eq(), DatumGetBool(), and PG_RETURN_BOOL.

array_nelems_size()

static int array_nelems_size ( char *  ptr, int  offset, bits8 *  nullbitmap, int  nitems, int  typlen, bool  typbyval, char  typalign  )

static

Definition at line 4915 of file arrayfuncs.c.

{
    return array_seek(ptr, offset, nullbitmap, nitems,
                      typlen, typbyval, typalign) - ptr;
}

References array_seek(), nitems, and typalign.

Referenced by array_copy(), and array_set_slice().

array_out()

Datum array_out

(

PG_FUNCTION_ARGS

)

Definition at line 1017 of file arrayfuncs.c.

{
    AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
    Oid         element_type = AARR_ELEMTYPE(v);
    int         typlen;
    bool        typbyval;
    char        typalign;
    char        typdelim;
    char       *p,
               *tmp,
               *retval,
              **values,
                dims_str[(MAXDIM * 33) + 2];
 
    /*
     * 33 per dim since we assume 15 digits per number + ':' +'[]'
     *
     * +2 allows for assignment operator + trailing null
     */
    bool       *needquotes,
                needdims = false;
    size_t      overall_length;
    int         nitems,
                i,
                j,
                k,
                indx[MAXDIM];
    int         ndim,
               *dims,
               *lb;
    array_iter  iter;
    ArrayMetaState *my_extra;
 
    /*
     * We arrange to look up info about element type, including its output
     * conversion proc, only once per series of calls, assuming the element
     * type doesn't change underneath us.
     */
    my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL)
    {
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(ArrayMetaState));
        my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
        my_extra->element_type = ~element_type;
    }
 
    if (my_extra->element_type != element_type)
    {
        /*
         * Get info about element type, including its output conversion proc
         */
        get_type_io_data(element_type, IOFunc_output,
                         &my_extra->typlen, &my_extra->typbyval,
                         &my_extra->typalign, &my_extra->typdelim,
                         &my_extra->typioparam, &my_extra->typiofunc);
        fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
                      fcinfo->flinfo->fn_mcxt);
        my_extra->element_type = element_type;
    }
    typlen = my_extra->typlen;
    typbyval = my_extra->typbyval;
    typalign = my_extra->typalign;
    typdelim = my_extra->typdelim;
 
    ndim = AARR_NDIM(v);
    dims = AARR_DIMS(v);
    lb = AARR_LBOUND(v);
    nitems = ArrayGetNItems(ndim, dims);
 
    if (nitems == 0)
    {
        retval = pstrdup("{}");
        PG_RETURN_CSTRING(retval);
    }
 
    /*
     * we will need to add explicit dimensions if any dimension has a lower
     * bound other than one
     */
    for (i = 0; i < ndim; i++)
    {
        if (lb[i] != 1)
        {
            needdims = true;
            break;
        }
    }
 
    /*
     * Convert all values to string form, count total space needed (including
     * any overhead such as escaping backslashes), and detect whether each
     * item needs double quotes.
     */
    values = (char **) palloc(nitems * sizeof(char *));
    needquotes = (bool *) palloc(nitems * sizeof(bool));
    overall_length = 0;
 
    array_iter_setup(&iter, v);
 
    for (i = 0; i < nitems; i++)
    {
        Datum       itemvalue;
        bool        isnull;
        bool        needquote;
 
        /* Get source element, checking for NULL */
        itemvalue = array_iter_next(&iter, &isnull, i,
                                    typlen, typbyval, typalign);
 
        if (isnull)
        {
            values[i] = pstrdup("NULL");
            overall_length += 4;
            needquote = false;
        }
        else
        {
            values[i] = OutputFunctionCall(&my_extra->proc, itemvalue);
 
            /* count data plus backslashes; detect chars needing quotes */
            if (values[i][0] == '\0')
                needquote = true;   /* force quotes for empty string */
            else if (pg_strcasecmp(values[i], "NULL") == 0)
                needquote = true;   /* force quotes for literal NULL */
            else
                needquote = false;
 
            for (tmp = values[i]; *tmp != '\0'; tmp++)
            {
                char        ch = *tmp;
 
                overall_length += 1;
                if (ch == '"' || ch == '\\')
                {
                    needquote = true;
                    overall_length += 1;
                }
                else if (ch == '{' || ch == '}' || ch == typdelim ||
                         scanner_isspace(ch))
                    needquote = true;
            }
        }
 
        needquotes[i] = needquote;
 
        /* Count the pair of double quotes, if needed */
        if (needquote)
            overall_length += 2;
        /* and the comma (or other typdelim delimiter) */
        overall_length += 1;
    }
 
    /*
     * The very last array element doesn't have a typdelim delimiter after it,
     * but that's OK; that space is needed for the trailing '\0'.
     *
     * Now count total number of curly brace pairs in output string.
     */
    for (i = j = 0, k = 1; i < ndim; i++)
    {
        j += k, k *= dims[i];
    }
    overall_length += 2 * j;
 
    /* Format explicit dimensions if required */
    dims_str[0] = '\0';
    if (needdims)
    {
        char       *ptr = dims_str;
 
        for (i = 0; i < ndim; i++)
        {
            sprintf(ptr, "[%d:%d]", lb[i], lb[i] + dims[i] - 1);
            ptr += strlen(ptr);
        }
        *ptr++ = *ASSGN;
        *ptr = '\0';
        overall_length += ptr - dims_str;
    }
 
    /* Now construct the output string */
    retval = (char *) palloc(overall_length);
    p = retval;
 
#define APPENDSTR(str)  (strcpy(p, (str)), p += strlen(p))
#define APPENDCHAR(ch)  (*p++ = (ch), *p = '\0')
 
    if (needdims)
        APPENDSTR(dims_str);
    APPENDCHAR('{');
    for (i = 0; i < ndim; i++)
        indx[i] = 0;
    j = 0;
    k = 0;
    do
    {
        for (i = j; i < ndim - 1; i++)
            APPENDCHAR('{');
 
        if (needquotes[k])
        {
            APPENDCHAR('"');
            for (tmp = values[k]; *tmp; tmp++)
            {
                char        ch = *tmp;
 
                if (ch == '"' || ch == '\\')
                    *p++ = '\\';
                *p++ = ch;
            }
            *p = '\0';
            APPENDCHAR('"');
        }
        else
            APPENDSTR(values[k]);
        pfree(values[k++]);
 
        for (i = ndim - 1; i >= 0; i--)
        {
            if (++(indx[i]) < dims[i])
            {
                APPENDCHAR(typdelim);
                break;
            }
            else
            {
                indx[i] = 0;
                APPENDCHAR('}');
            }
        }
        j = i;
    } while (j != -1);
 
#undef APPENDSTR
#undef APPENDCHAR
 
    /* Assert that we calculated the string length accurately */
    Assert(overall_length == (p - retval + 1));
 
    pfree(values);
    pfree(needquotes);
 
    PG_RETURN_CSTRING(retval);
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_LBOUND, AARR_NDIM, APPENDCHAR, APPENDSTR, array_iter_next(), array_iter_setup(), ArrayGetNItems(), Assert(), ASSGN, ArrayMetaState::element_type, fmgr_info_cxt(), FmgrInfo::fn_mcxt, get_type_io_data(), i, if(), IOFunc_output, j, MAXDIM, MemoryContextAlloc(), nitems, OutputFunctionCall(), palloc(), pfree(), PG_GETARG_ANY_ARRAY_P, PG_RETURN_CSTRING, pg_strcasecmp(), ArrayMetaState::proc, pstrdup(), scanner_isspace(), sprintf, typalign, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, ArrayMetaState::typlen, and values.

Referenced by anyarray_out(), and anycompatiblearray_out().

array_recv()

Datum array_recv

(

PG_FUNCTION_ARGS

)

Definition at line 1272 of file arrayfuncs.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    Oid         spec_element_type = PG_GETARG_OID(1);   /* type of an array
                                                         * element */
    int32       typmod = PG_GETARG_INT32(2);    /* typmod for array elements */
    Oid         element_type;
    int         typlen;
    bool        typbyval;
    char        typalign;
    Oid         typioparam;
    int         i,
                nitems;
    Datum      *dataPtr;
    bool       *nullsPtr;
    bool        hasnulls;
    int32       nbytes;
    int32       dataoffset;
    ArrayType  *retval;
    int         ndim,
                flags,
                dim[MAXDIM],
                lBound[MAXDIM];
    ArrayMetaState *my_extra;
 
    /* Get the array header information */
    ndim = pq_getmsgint(buf, 4);
    if (ndim < 0)               /* we do allow zero-dimension arrays */
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid number of dimensions: %d", ndim)));
    if (ndim > MAXDIM)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
                        ndim, MAXDIM)));
 
    flags = pq_getmsgint(buf, 4);
    if (flags != 0 && flags != 1)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid array flags")));
 
    /* Check element type recorded in the data */
    element_type = pq_getmsgint(buf, sizeof(Oid));
 
    /*
     * From a security standpoint, it doesn't matter whether the input's
     * element type matches what we expect: the element type's receive
     * function has to be robust enough to cope with invalid data.  However,
     * from a user-friendliness standpoint, it's nicer to complain about type
     * mismatches than to throw "improper binary format" errors.  But there's
     * a problem: only built-in types have OIDs that are stable enough to
     * believe that a mismatch is a real issue.  So complain only if both OIDs
     * are in the built-in range.  Otherwise, carry on with the element type
     * we "should" be getting.
     */
    if (element_type != spec_element_type)
    {
        if (element_type < FirstGenbkiObjectId &&
            spec_element_type < FirstGenbkiObjectId)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("binary data has array element type %u (%s) instead of expected %u (%s)",
                            element_type,
                            format_type_extended(element_type, -1,
                                                 FORMAT_TYPE_ALLOW_INVALID),
                            spec_element_type,
                            format_type_extended(spec_element_type, -1,
                                                 FORMAT_TYPE_ALLOW_INVALID))));
        element_type = spec_element_type;
    }
 
    for (i = 0; i < ndim; i++)
    {
        dim[i] = pq_getmsgint(buf, 4);
        lBound[i] = pq_getmsgint(buf, 4);
    }
 
    /* This checks for overflow of array dimensions */
    nitems = ArrayGetNItems(ndim, dim);
    ArrayCheckBounds(ndim, dim, lBound);
 
    /*
     * We arrange to look up info about element type, including its receive
     * conversion proc, only once per series of calls, assuming the element
     * type doesn't change underneath us.
     */
    my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL)
    {
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(ArrayMetaState));
        my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
        my_extra->element_type = ~element_type;
    }
 
    if (my_extra->element_type != element_type)
    {
        /* Get info about element type, including its receive proc */
        get_type_io_data(element_type, IOFunc_receive,
                         &my_extra->typlen, &my_extra->typbyval,
                         &my_extra->typalign, &my_extra->typdelim,
                         &my_extra->typioparam, &my_extra->typiofunc);
        if (!OidIsValid(my_extra->typiofunc))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("no binary input function available for type %s",
                            format_type_be(element_type))));
        fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
                      fcinfo->flinfo->fn_mcxt);
        my_extra->element_type = element_type;
    }
 
    if (nitems == 0)
    {
        /* Return empty array ... but not till we've validated element_type */
        PG_RETURN_ARRAYTYPE_P(construct_empty_array(element_type));
    }
 
    typlen = my_extra->typlen;
    typbyval = my_extra->typbyval;
    typalign = my_extra->typalign;
    typioparam = my_extra->typioparam;
 
    dataPtr = (Datum *) palloc(nitems * sizeof(Datum));
    nullsPtr = (bool *) palloc(nitems * sizeof(bool));
    ReadArrayBinary(buf, nitems,
                    &my_extra->proc, typioparam, typmod,
                    typlen, typbyval, typalign,
                    dataPtr, nullsPtr,
                    &hasnulls, &nbytes);
    if (hasnulls)
    {
        dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
        nbytes += dataoffset;
    }
    else
    {
        dataoffset = 0;         /* marker for no null bitmap */
        nbytes += ARR_OVERHEAD_NONULLS(ndim);
    }
    retval = (ArrayType *) palloc0(nbytes);
    SET_VARSIZE(retval, nbytes);
    retval->ndim = ndim;
    retval->dataoffset = dataoffset;
    retval->elemtype = element_type;
    memcpy(ARR_DIMS(retval), dim, ndim * sizeof(int));
    memcpy(ARR_LBOUND(retval), lBound, ndim * sizeof(int));
 
    CopyArrayEls(retval,
                 dataPtr, nullsPtr, nitems,
                 typlen, typbyval, typalign,
                 true);
 
    pfree(dataPtr);
    pfree(nullsPtr);
 
    PG_RETURN_ARRAYTYPE_P(retval);
}

References ARR_DIMS, ARR_LBOUND, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ArrayCheckBounds(), ArrayGetNItems(), buf, construct_empty_array(), CopyArrayEls(), ArrayType::dataoffset, ArrayMetaState::element_type, ArrayType::elemtype, ereport, errcode(), errmsg(), ERROR, FirstGenbkiObjectId, fmgr_info_cxt(), FmgrInfo::fn_mcxt, FORMAT_TYPE_ALLOW_INVALID, format_type_be(), format_type_extended(), get_type_io_data(), i, if(), IOFunc_receive, MAXDIM, MemoryContextAlloc(), ArrayType::ndim, nitems, OidIsValid, palloc(), palloc0(), pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_ARRAYTYPE_P, pq_getmsgint(), ArrayMetaState::proc, ReadArrayBinary(), SET_VARSIZE(), typalign, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, and ArrayMetaState::typlen.

Referenced by int2vectorrecv(), and oidvectorrecv().

array_ref()

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

Definition at line 3147 of file arrayfuncs.c.

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

References array_get_element(), and PointerGetDatum().

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

array_remove()

Datum array_remove

(

PG_FUNCTION_ARGS

)

Definition at line 6640 of file arrayfuncs.c.

{
    ArrayType  *array;
    Datum       search = PG_GETARG_DATUM(1);
    bool        search_isnull = PG_ARGISNULL(1);
 
    if (PG_ARGISNULL(0))
        PG_RETURN_NULL();
    array = PG_GETARG_ARRAYTYPE_P(0);
 
    array = array_replace_internal(array,
                                   search, search_isnull,
                                   (Datum) 0, true,
                                   true, PG_GET_COLLATION(),
                                   fcinfo);
    PG_RETURN_ARRAYTYPE_P(array);
}

References array_replace_internal(), PG_ARGISNULL, PG_GET_COLLATION, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_RETURN_ARRAYTYPE_P, and PG_RETURN_NULL.

array_replace()

Datum array_replace

(

PG_FUNCTION_ARGS

)

Definition at line 6662 of file arrayfuncs.c.

{
    ArrayType  *array;
    Datum       search = PG_GETARG_DATUM(1);
    bool        search_isnull = PG_ARGISNULL(1);
    Datum       replace = PG_GETARG_DATUM(2);
    bool        replace_isnull = PG_ARGISNULL(2);
 
    if (PG_ARGISNULL(0))
        PG_RETURN_NULL();
    array = PG_GETARG_ARRAYTYPE_P(0);
 
    array = array_replace_internal(array,
                                   search, search_isnull,
                                   replace, replace_isnull,
                                   false, PG_GET_COLLATION(),
                                   fcinfo);
    PG_RETURN_ARRAYTYPE_P(array);
}

References array_replace_internal(), PG_ARGISNULL, PG_GET_COLLATION, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_RETURN_ARRAYTYPE_P, and PG_RETURN_NULL.

array_replace_internal()

static ArrayType * array_replace_internal ( ArrayType *  array, Datum  search, bool  search_isnull, Datum  replace, bool  replace_isnull, bool  remove, Oid  collation, FunctionCallInfo  fcinfo  )

static

Definition at line 6382 of file arrayfuncs.c.

{
    LOCAL_FCINFO(locfcinfo, 2);
    ArrayType  *result;
    Oid         element_type;
    Datum      *values;
    bool       *nulls;
    int        *dim;
    int         ndim;
    int         nitems,
                nresult;
    int         i;
    int32       nbytes = 0;
    int32       dataoffset;
    bool        hasnulls;
    int         typlen;
    bool        typbyval;
    char        typalign;
    char       *arraydataptr;
    bits8      *bitmap;
    int         bitmask;
    bool        changed = false;
    TypeCacheEntry *typentry;
 
    element_type = ARR_ELEMTYPE(array);
    ndim = ARR_NDIM(array);
    dim = ARR_DIMS(array);
    nitems = ArrayGetNItems(ndim, dim);
 
    /* Return input array unmodified if it is empty */
    if (nitems <= 0)
        return array;
 
    /*
     * We can't remove elements from multi-dimensional arrays, since the
     * result might not be rectangular.
     */
    if (remove && ndim > 1)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("removing elements from multidimensional arrays is not supported")));
 
    /*
     * We arrange to look up the equality function only once per series of
     * calls, assuming the element type doesn't change underneath us.
     */
    typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
    if (typentry == NULL ||
        typentry->type_id != element_type)
    {
        typentry = lookup_type_cache(element_type,
                                     TYPECACHE_EQ_OPR_FINFO);
        if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("could not identify an equality operator for type %s",
                            format_type_be(element_type))));
        fcinfo->flinfo->fn_extra = typentry;
    }
    typlen = typentry->typlen;
    typbyval = typentry->typbyval;
    typalign = typentry->typalign;
 
    /*
     * Detoast values if they are toasted.  The replacement value must be
     * detoasted for insertion into the result array, while detoasting the
     * search value only once saves cycles.
     */
    if (typlen == -1)
    {
        if (!search_isnull)
            search = PointerGetDatum(PG_DETOAST_DATUM(search));
        if (!replace_isnull)
            replace = PointerGetDatum(PG_DETOAST_DATUM(replace));
    }
 
    /* Prepare to apply the comparison operator */
    InitFunctionCallInfoData(*locfcinfo, &typentry->eq_opr_finfo, 2,
                             collation, NULL, NULL);
 
    /* Allocate temporary arrays for new values */
    values = (Datum *) palloc(nitems * sizeof(Datum));
    nulls = (bool *) palloc(nitems * sizeof(bool));
 
    /* Loop over source data */
    arraydataptr = ARR_DATA_PTR(array);
    bitmap = ARR_NULLBITMAP(array);
    bitmask = 1;
    hasnulls = false;
    nresult = 0;
 
    for (i = 0; i < nitems; i++)
    {
        Datum       elt;
        bool        isNull;
        bool        oprresult;
        bool        skip = false;
 
        /* Get source element, checking for NULL */
        if (bitmap && (*bitmap & bitmask) == 0)
        {
            isNull = true;
            /* If searching for NULL, we have a match */
            if (search_isnull)
            {
                if (remove)
                {
                    skip = true;
                    changed = true;
                }
                else if (!replace_isnull)
                {
                    values[nresult] = replace;
                    isNull = false;
                    changed = true;
                }
            }
        }
        else
        {
            isNull = false;
            elt = fetch_att(arraydataptr, typbyval, typlen);
            arraydataptr = att_addlength_datum(arraydataptr, typlen, elt);
            arraydataptr = (char *) att_align_nominal(arraydataptr, typalign);
 
            if (search_isnull)
            {
                /* no match possible, keep element */
                values[nresult] = elt;
            }
            else
            {
                /*
                 * Apply the operator to the element pair; treat NULL as false
                 */
                locfcinfo->args[0].value = elt;
                locfcinfo->args[0].isnull = false;
                locfcinfo->args[1].value = search;
                locfcinfo->args[1].isnull = false;
                locfcinfo->isnull = false;
                oprresult = DatumGetBool(FunctionCallInvoke(locfcinfo));
                if (locfcinfo->isnull || !oprresult)
                {
                    /* no match, keep element */
                    values[nresult] = elt;
                }
                else
                {
                    /* match, so replace or delete */
                    changed = true;
                    if (remove)
                        skip = true;
                    else
                    {
                        values[nresult] = replace;
                        isNull = replace_isnull;
                    }
                }
            }
        }
 
        if (!skip)
        {
            nulls[nresult] = isNull;
            if (isNull)
                hasnulls = true;
            else
            {
                /* Update total result size */
                nbytes = att_addlength_datum(nbytes, typlen, values[nresult]);
                nbytes = att_align_nominal(nbytes, typalign);
                /* check for overflow of total request */
                if (!AllocSizeIsValid(nbytes))
                    ereport(ERROR,
                            (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                             errmsg("array size exceeds the maximum allowed (%d)",
                                    (int) MaxAllocSize)));
            }
            nresult++;
        }
 
        /* advance bitmap pointer if any */
        if (bitmap)
        {
            bitmask <<= 1;
            if (bitmask == 0x100)
            {
                bitmap++;
                bitmask = 1;
            }
        }
    }
 
    /*
     * If not changed just return the original array
     */
    if (!changed)
    {
        pfree(values);
        pfree(nulls);
        return array;
    }
 
    /* If all elements were removed return an empty array */
    if (nresult == 0)
    {
        pfree(values);
        pfree(nulls);
        return construct_empty_array(element_type);
    }
 
    /* Allocate and initialize the result array */
    if (hasnulls)
    {
        dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nresult);
        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 = element_type;
    memcpy(ARR_DIMS(result), ARR_DIMS(array), ndim * sizeof(int));
    memcpy(ARR_LBOUND(result), ARR_LBOUND(array), ndim * sizeof(int));
 
    if (remove)
    {
        /* Adjust the result length */
        ARR_DIMS(result)[0] = nresult;
    }
 
    /* Insert data into result array */
    CopyArrayEls(result,
                 values, nulls, nresult,
                 typlen, typbyval, typalign,
                 false);
 
    pfree(values);
    pfree(nulls);
 
    return result;
}

References AllocSizeIsValid, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ArrayGetNItems(), att_addlength_datum, att_align_nominal, construct_empty_array(), CopyArrayEls(), ArrayType::dataoffset, DatumGetBool(), ArrayType::elemtype, TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, fetch_att(), FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, i, if(), InitFunctionCallInfoData, LOCAL_FCINFO, lookup_type_cache(), MaxAllocSize, ArrayType::ndim, nitems, OidIsValid, palloc(), palloc0(), pfree(), PG_DETOAST_DATUM, PointerGetDatum(), SET_VARSIZE(), skip, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_EQ_OPR_FINFO, TypeCacheEntry::typlen, and values.

Referenced by array_remove(), and array_replace().

array_seek()

static char * array_seek ( char *  ptr, int  offset, bits8 *  nullbitmap, int  nitems, int  typlen, bool  typbyval, char  typalign  )

static

Definition at line 4867 of file arrayfuncs.c.

{
    int         bitmask;
    int         i;
 
    /* easy if fixed-size elements and no NULLs */
    if (typlen > 0 && !nullbitmap)
        return ptr + nitems * ((Size) att_align_nominal(typlen, typalign));
 
    /* seems worth having separate loops for NULL and no-NULLs cases */
    if (nullbitmap)
    {
        nullbitmap += offset / 8;
        bitmask = 1 << (offset % 8);
 
        for (i = 0; i < nitems; i++)
        {
            if (*nullbitmap & bitmask)
            {
                ptr = att_addlength_pointer(ptr, typlen, ptr);
                ptr = (char *) att_align_nominal(ptr, typalign);
            }
            bitmask <<= 1;
            if (bitmask == 0x100)
            {
                nullbitmap++;
                bitmask = 1;
            }
        }
    }
    else
    {
        for (i = 0; i < nitems; i++)
        {
            ptr = att_addlength_pointer(ptr, typlen, ptr);
            ptr = (char *) att_align_nominal(ptr, typalign);
        }
    }
    return ptr;
}

References att_addlength_pointer, att_align_nominal, i, nitems, and typalign.

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

array_send()

Datum array_send

(

PG_FUNCTION_ARGS

)

Definition at line 1549 of file arrayfuncs.c.

{
    AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
    Oid         element_type = AARR_ELEMTYPE(v);
    int         typlen;
    bool        typbyval;
    char        typalign;
    int         nitems,
                i;
    int         ndim,
               *dim,
               *lb;
    StringInfoData buf;
    array_iter  iter;
    ArrayMetaState *my_extra;
 
    /*
     * We arrange to look up info about element type, including its send
     * conversion proc, only once per series of calls, assuming the element
     * type doesn't change underneath us.
     */
    my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL)
    {
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(ArrayMetaState));
        my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
        my_extra->element_type = ~element_type;
    }
 
    if (my_extra->element_type != element_type)
    {
        /* Get info about element type, including its send proc */
        get_type_io_data(element_type, IOFunc_send,
                         &my_extra->typlen, &my_extra->typbyval,
                         &my_extra->typalign, &my_extra->typdelim,
                         &my_extra->typioparam, &my_extra->typiofunc);
        if (!OidIsValid(my_extra->typiofunc))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("no binary output function available for type %s",
                            format_type_be(element_type))));
        fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
                      fcinfo->flinfo->fn_mcxt);
        my_extra->element_type = element_type;
    }
    typlen = my_extra->typlen;
    typbyval = my_extra->typbyval;
    typalign = my_extra->typalign;
 
    ndim = AARR_NDIM(v);
    dim = AARR_DIMS(v);
    lb = AARR_LBOUND(v);
    nitems = ArrayGetNItems(ndim, dim);
 
    pq_begintypsend(&buf);
 
    /* Send the array header information */
    pq_sendint32(&buf, ndim);
    pq_sendint32(&buf, AARR_HASNULL(v) ? 1 : 0);
    pq_sendint32(&buf, element_type);
    for (i = 0; i < ndim; i++)
    {
        pq_sendint32(&buf, dim[i]);
        pq_sendint32(&buf, lb[i]);
    }
 
    /* Send the array elements using the element's own sendproc */
    array_iter_setup(&iter, v);
 
    for (i = 0; i < nitems; i++)
    {
        Datum       itemvalue;
        bool        isnull;
 
        /* Get source element, checking for NULL */
        itemvalue = array_iter_next(&iter, &isnull, i,
                                    typlen, typbyval, typalign);
 
        if (isnull)
        {
            /* -1 length means a NULL */
            pq_sendint32(&buf, -1);
        }
        else
        {
            bytea      *outputbytes;
 
            outputbytes = SendFunctionCall(&my_extra->proc, itemvalue);
            pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
            pq_sendbytes(&buf, VARDATA(outputbytes),
                         VARSIZE(outputbytes) - VARHDRSZ);
            pfree(outputbytes);
        }
    }
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_HASNULL, AARR_LBOUND, AARR_NDIM, array_iter_next(), array_iter_setup(), ArrayGetNItems(), buf, ArrayMetaState::element_type, ereport, errcode(), errmsg(), ERROR, fmgr_info_cxt(), FmgrInfo::fn_mcxt, format_type_be(), get_type_io_data(), i, if(), IOFunc_send, MemoryContextAlloc(), nitems, OidIsValid, pfree(), PG_GETARG_ANY_ARRAY_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbytes(), pq_sendint32(), ArrayMetaState::proc, SendFunctionCall(), typalign, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, ArrayMetaState::typlen, VARDATA(), VARHDRSZ, and VARSIZE().

Referenced by anyarray_send(), anycompatiblearray_send(), int2vectorsend(), and oidvectorsend().

array_set()

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

Definition at line 3164 of file arrayfuncs.c.

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

References array_set_element(), DatumGetArrayTypeP, 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
	)

Definition at line 2202 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;
 
    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 = (char *) resultarray + indx[0] * elmlen;
        ArrayCastAndSet(dataValue, elmlen, elmbyval, elmalign, 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 (%d)",
                                (int) 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 (%d)",
                                (int) 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_align_nominal(olditemlen, elmalign);
        }
        lenafter = (int) (olddatasize - lenbefore - olditemlen);
    }
 
    if (isNull)
        newitemlen = 0;
    else
    {
        newitemlen = att_addlength_datum(0, elmlen, dataValue);
        newitemlen = att_align_nominal(newitemlen, elmalign);
    }
 
    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, elmalign,
                        (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_align_nominal, construct_md_array(), ArrayType::dataoffset, DatumGetArrayTypeP, DatumGetPointer(), ArrayType::elemtype, ereport, errcode(), errmsg(), ERROR, i, MaxArraySize, MAXDIM, ArrayType::ndim, palloc(), palloc0(), pg_add_s32_overflow(), PG_DETOAST_DATUM, pg_sub_s32_overflow(), PointerGetDatum(), SET_VARSIZE(), and VARATT_IS_EXTERNAL_EXPANDED().

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

array_set_element_expanded()

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

static

Definition at line 2502 of file arrayfuncs.c.

{
    ExpandedArrayHeader *eah;
    Datum      *dvalues;
    bool       *dnulls;
    int         i,
                ndim,
                dim[MAXDIM],
                lb[MAXDIM],
                offset;
    bool        dimschanged,
                newhasnulls;
    int         addedbefore,
                addedafter;
    char       *oldValue;
 
    /* Convert to R/W object if not so already */
    eah = DatumGetExpandedArray(arraydatum);
 
    /* Sanity-check caller's info against object; we don't use it otherwise */
    Assert(arraytyplen == -1);
    Assert(elmlen == eah->typlen);
    Assert(elmbyval == eah->typbyval);
    Assert(elmalign == eah->typalign);
 
    /*
     * Copy dimension info into local storage.  This allows us to modify the
     * dimensions if needed, while not messing up the expanded value if we
     * fail partway through.
     */
    ndim = eah->ndims;
    Assert(ndim >= 0 && ndim <= MAXDIM);
    memcpy(dim, eah->dims, ndim * sizeof(int));
    memcpy(lb, eah->lbound, ndim * sizeof(int));
    dimschanged = false;
 
    /*
     * 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)
    {
        /*
         * Allocate adequate space for new dimension info.  This is harmless
         * if we fail later.
         */
        Assert(nSubscripts > 0 && nSubscripts <= MAXDIM);
        eah->dims = (int *) MemoryContextAllocZero(eah->hdr.eoh_context,
                                                   nSubscripts * sizeof(int));
        eah->lbound = (int *) MemoryContextAllocZero(eah->hdr.eoh_context,
                                                     nSubscripts * sizeof(int));
 
        /* Update local copies of dimension info */
        ndim = nSubscripts;
        for (i = 0; i < nSubscripts; i++)
        {
            dim[i] = 0;
            lb[i] = indx[i];
        }
        dimschanged = true;
    }
    else if (ndim != nSubscripts)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("wrong number of array subscripts")));
 
    /*
     * Deconstruct array if we didn't already.  (Someday maybe add a special
     * case path for fixed-length, no-nulls cases, where we can overwrite an
     * element in place without ever deconstructing.  But today is not that
     * day.)
     */
    deconstruct_expanded_array(eah);
 
    /*
     * Copy new element into array's context, if needed (we assume it's
     * already detoasted, so no junk should be created).  Doing this before
     * we've made any significant changes ensures that our behavior is sane
     * even when the source is a reference to some element of this same array.
     * If we fail further down, this memory is leaked, but that's reasonably
     * harmless.
     */
    if (!eah->typbyval && !isNull)
    {
        MemoryContext oldcxt = MemoryContextSwitchTo(eah->hdr.eoh_context);
 
        dataValue = datumCopy(dataValue, false, eah->typlen);
        MemoryContextSwitchTo(oldcxt);
    }
 
    dvalues = eah->dvalues;
    dnulls = eah->dnulls;
 
    newhasnulls = ((dnulls != NULL) || isNull);
    addedbefore = addedafter = 0;
 
    /*
     * Check subscripts (this logic must match array_set_element).  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 (%d)",
                                (int) MaxArraySize)));
            lb[0] = indx[0];
            dimschanged = true;
            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 (%d)",
                                (int) MaxArraySize)));
            dimschanged = true;
            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")));
        }
    }
 
    /* Check for overflow of the array dimensions */
    if (dimschanged)
    {
        (void) ArrayGetNItems(ndim, dim);
        ArrayCheckBounds(ndim, dim, lb);
    }
 
    /* Now we can calculate linear offset of target item in array */
    offset = ArrayGetOffset(nSubscripts, dim, lb, indx);
 
    /* Physically enlarge existing dvalues/dnulls arrays if needed */
    if (dim[0] > eah->dvalueslen)
    {
        /* We want some extra space if we're enlarging */
        int         newlen = dim[0] + dim[0] / 8;
 
        newlen = Max(newlen, dim[0]);   /* integer overflow guard */
        eah->dvalues = dvalues = (Datum *)
            repalloc(dvalues, newlen * sizeof(Datum));
        if (dnulls)
            eah->dnulls = dnulls = (bool *)
                repalloc(dnulls, newlen * sizeof(bool));
        eah->dvalueslen = newlen;
    }
 
    /*
     * If we need a nulls bitmap and don't already have one, create it, being
     * sure to mark all existing entries as not null.
     */
    if (newhasnulls && dnulls == NULL)
        eah->dnulls = dnulls = (bool *)
            MemoryContextAllocZero(eah->hdr.eoh_context,
                                   eah->dvalueslen * sizeof(bool));
 
    /*
     * We now have all the needed space allocated, so we're ready to make
     * irreversible changes.  Be very wary of allowing failure below here.
     */
 
    /* Flattened value will no longer represent array accurately */
    eah->fvalue = NULL;
    /* And we don't know the flattened size either */
    eah->flat_size = 0;
 
    /* Update dimensionality info if needed */
    if (dimschanged)
    {
        eah->ndims = ndim;
        memcpy(eah->dims, dim, ndim * sizeof(int));
        memcpy(eah->lbound, lb, ndim * sizeof(int));
    }
 
    /* Reposition items if needed, and fill addedbefore items with nulls */
    if (addedbefore > 0)
    {
        memmove(dvalues + addedbefore, dvalues, eah->nelems * sizeof(Datum));
        for (i = 0; i < addedbefore; i++)
            dvalues[i] = (Datum) 0;
        if (dnulls)
        {
            memmove(dnulls + addedbefore, dnulls, eah->nelems * sizeof(bool));
            for (i = 0; i < addedbefore; i++)
                dnulls[i] = true;
        }
        eah->nelems += addedbefore;
    }
 
    /* fill addedafter items with nulls */
    if (addedafter > 0)
    {
        for (i = 0; i < addedafter; i++)
            dvalues[eah->nelems + i] = (Datum) 0;
        if (dnulls)
        {
            for (i = 0; i < addedafter; i++)
                dnulls[eah->nelems + i] = true;
        }
        eah->nelems += addedafter;
    }
 
    /* Grab old element value for pfree'ing, if needed. */
    if (!eah->typbyval && (dnulls == NULL || !dnulls[offset]))
        oldValue = (char *) DatumGetPointer(dvalues[offset]);
    else
        oldValue = NULL;
 
    /* And finally we can insert the new element. */
    dvalues[offset] = dataValue;
    if (dnulls)
        dnulls[offset] = isNull;
 
    /*
     * Free old element if needed; this keeps repeated element replacements
     * from bloating the array's storage.  If the pfree somehow fails, it
     * won't corrupt the array.
     */
    if (oldValue)
    {
        /* Don't try to pfree a part of the original flat array */
        if (oldValue < eah->fstartptr || oldValue >= eah->fendptr)
            pfree(oldValue);
    }
 
    /* Done, return standard TOAST pointer for object */
    return EOHPGetRWDatum(&eah->hdr);
}

References ArrayCheckBounds(), ArrayGetNItems(), ArrayGetOffset(), Assert(), datumCopy(), DatumGetExpandedArray(), DatumGetPointer(), deconstruct_expanded_array(), ExpandedArrayHeader::dims, ExpandedArrayHeader::dnulls, ExpandedArrayHeader::dvalues, ExpandedArrayHeader::dvalueslen, ExpandedObjectHeader::eoh_context, EOHPGetRWDatum(), ereport, errcode(), errmsg(), ERROR, ExpandedArrayHeader::fendptr, ExpandedArrayHeader::flat_size, ExpandedArrayHeader::fvalue, ExpandedArrayHeader::hdr, i, ExpandedArrayHeader::lbound, Max, MaxArraySize, MAXDIM, MemoryContextAllocZero(), MemoryContextSwitchTo(), ExpandedArrayHeader::ndims, ExpandedArrayHeader::nelems, pfree(), pg_add_s32_overflow(), pg_sub_s32_overflow(), repalloc(), ExpandedArrayHeader::typalign, ExpandedArrayHeader::typbyval, and ExpandedArrayHeader::typlen.

Referenced by array_set_element().

array_set_isnull()

static void array_set_isnull ( bits8 *  nullbitmap, int  offset, bool  isNull  )

static

Definition at line 4799 of file arrayfuncs.c.

{
    int         bitmask;
 
    nullbitmap += offset / 8;
    bitmask = 1 << (offset % 8);
    if (isNull)
        *nullbitmap &= ~bitmask;
    else
        *nullbitmap |= bitmask;
}

Referenced by array_set_element().

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
	)

Definition at line 2807 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 (%d)",
                                (int) 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 (%d)",
                                (int) 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 (%d)",
                                (int) 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(), ArrayType::dataoffset, DatumGetArrayTypeP, deconstruct_array(), ArrayType::elemtype, ereport, errcode(), errdetail(), errmsg(), ERROR, i, Max, MaxArraySize, MAXDIM, mda_get_range(), Min, ArrayType::ndim, nitems, palloc0(), pg_add_s32_overflow(), pg_sub_s32_overflow(), PointerGetDatum(), and SET_VARSIZE().

Referenced by array_subscript_assign_slice().

array_slice_size()

static int array_slice_size ( char *  arraydataptr, bits8 *  arraynullsptr, int  ndim, int *  dim, int *  lb, int *  st, int *  endp, int  typlen, bool  typbyval, char  typalign  )

static

Definition at line 5038 of file arrayfuncs.c.

{
    int         src_offset,
                span[MAXDIM],
                prod[MAXDIM],
                dist[MAXDIM],
                indx[MAXDIM];
    char       *ptr;
    int         i,
                j,
                inc;
    int         count = 0;
 
    mda_get_range(ndim, span, st, endp);
 
    /* Pretty easy for fixed element length without nulls ... */
    if (typlen > 0 && !arraynullsptr)
        return ArrayGetNItems(ndim, span) * att_align_nominal(typlen, typalign);
 
    /* Else gotta do it the hard way */
    src_offset = ArrayGetOffset(ndim, dim, lb, st);
    ptr = array_seek(arraydataptr, 0, arraynullsptr, src_offset,
                     typlen, typbyval, typalign);
    mda_get_prod(ndim, dim, prod);
    mda_get_offset_values(ndim, dist, prod, span);
    for (i = 0; i < ndim; i++)
        indx[i] = 0;
    j = ndim - 1;
    do
    {
        if (dist[j])
        {
            ptr = array_seek(ptr, src_offset, arraynullsptr, dist[j],
                             typlen, typbyval, typalign);
            src_offset += dist[j];
        }
        if (!array_get_isnull(arraynullsptr, src_offset))
        {
            inc = att_addlength_pointer(0, typlen, ptr);
            inc = att_align_nominal(inc, typalign);
            ptr += inc;
            count += inc;
        }
        src_offset++;
    } while ((j = mda_next_tuple(ndim, indx, span)) != -1);
    return count;
}

References array_get_isnull(), array_seek(), ArrayGetNItems(), ArrayGetOffset(), att_addlength_pointer, att_align_nominal, i, j, MAXDIM, mda_get_offset_values(), mda_get_prod(), mda_get_range(), mda_next_tuple(), and typalign.

Referenced by array_get_slice(), and array_set_slice().

array_smaller()

Datum array_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 5897 of file arrayfuncs.c.

{
    if (array_cmp(fcinfo) < 0)
        PG_RETURN_DATUM(PG_GETARG_DATUM(0));
    else
        PG_RETURN_DATUM(PG_GETARG_DATUM(1));
}

References array_cmp(), PG_GETARG_DATUM, and PG_RETURN_DATUM.

array_unnest()

Datum array_unnest

(

PG_FUNCTION_ARGS

)

Definition at line 6255 of file arrayfuncs.c.

{
    typedef struct
    {
        array_iter  iter;
        int         nextelem;
        int         numelems;
        int16       elmlen;
        bool        elmbyval;
        char        elmalign;
    } array_unnest_fctx;
 
    FuncCallContext *funcctx;
    array_unnest_fctx *fctx;
    MemoryContext oldcontext;
 
    /* stuff done only on the first call of the function */
    if (SRF_IS_FIRSTCALL())
    {
        AnyArrayType *arr;
 
        /* create a function context for cross-call persistence */
        funcctx = SRF_FIRSTCALL_INIT();
 
        /*
         * switch to memory context appropriate for multiple function calls
         */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /*
         * Get the array value and detoast if needed.  We can't do this
         * earlier because if we have to detoast, we want the detoasted copy
         * to be in multi_call_memory_ctx, so it will go away when we're done
         * and not before.  (If no detoast happens, we assume the originally
         * passed array will stick around till then.)
         */
        arr = PG_GETARG_ANY_ARRAY_P(0);
 
        /* allocate memory for user context */
        fctx = (array_unnest_fctx *) palloc(sizeof(array_unnest_fctx));
 
        /* initialize state */
        array_iter_setup(&fctx->iter, arr);
        fctx->nextelem = 0;
        fctx->numelems = ArrayGetNItems(AARR_NDIM(arr), AARR_DIMS(arr));
 
        if (VARATT_IS_EXPANDED_HEADER(arr))
        {
            /* we can just grab the type data from expanded array */
            fctx->elmlen = arr->xpn.typlen;
            fctx->elmbyval = arr->xpn.typbyval;
            fctx->elmalign = arr->xpn.typalign;
        }
        else
            get_typlenbyvalalign(AARR_ELEMTYPE(arr),
                                 &fctx->elmlen,
                                 &fctx->elmbyval,
                                 &fctx->elmalign);
 
        funcctx->user_fctx = fctx;
        MemoryContextSwitchTo(oldcontext);
    }
 
    /* stuff done on every call of the function */
    funcctx = SRF_PERCALL_SETUP();
    fctx = funcctx->user_fctx;
 
    if (fctx->nextelem < fctx->numelems)
    {
        int         offset = fctx->nextelem++;
        Datum       elem;
 
        elem = array_iter_next(&fctx->iter, &fcinfo->isnull, offset,
                               fctx->elmlen, fctx->elmbyval, fctx->elmalign);
 
        SRF_RETURN_NEXT(funcctx, elem);
    }
    else
    {
        /* do when there is no more left */
        SRF_RETURN_DONE(funcctx);
    }
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_NDIM, array_iter_next(), array_iter_setup(), ArrayGetNItems(), get_typlenbyvalalign(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, palloc(), PG_GETARG_ANY_ARRAY_P, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, ExpandedArrayHeader::typalign, ExpandedArrayHeader::typbyval, ExpandedArrayHeader::typlen, FuncCallContext::user_fctx, VARATT_IS_EXPANDED_HEADER, and AnyArrayType::xpn.

array_unnest_support()

Datum array_unnest_support

(

PG_FUNCTION_ARGS

)

Definition at line 6346 of file arrayfuncs.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestRows))
    {
        /* Try to estimate the number of rows returned */
        SupportRequestRows *req = (SupportRequestRows *) rawreq;
 
        if (is_funcclause(req->node))   /* be paranoid */
        {
            List       *args = ((FuncExpr *) req->node)->args;
            Node       *arg1;
 
            /* We can use estimated argument values here */
            arg1 = estimate_expression_value(req->root, linitial(args));
 
            req->rows = estimate_array_length(req->root, arg1);
            ret = (Node *) req;
        }
    }
 
    PG_RETURN_POINTER(ret);
}

References generate_unaccent_rules::args, estimate_array_length(), estimate_expression_value(), is_funcclause(), IsA, linitial, SupportRequestRows::node, PG_GETARG_POINTER, PG_RETURN_POINTER, SupportRequestRows::root, and SupportRequestRows::rows.

array_upper()

Datum array_upper

(

PG_FUNCTION_ARGS

)

Definition at line 1734 of file arrayfuncs.c.

{
    AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
    int         reqdim = PG_GETARG_INT32(1);
    int        *dimv,
               *lb;
    int         result;
 
    /* Sanity check: does it look like an array at all? */
    if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
        PG_RETURN_NULL();
 
    /* Sanity check: was the requested dim valid */
    if (reqdim <= 0 || reqdim > AARR_NDIM(v))
        PG_RETURN_NULL();
 
    lb = AARR_LBOUND(v);
    dimv = AARR_DIMS(v);
 
    result = dimv[reqdim - 1] + lb[reqdim - 1] - 1;
 
    PG_RETURN_INT32(result);
}

References AARR_DIMS, AARR_LBOUND, AARR_NDIM, MAXDIM, PG_GETARG_ANY_ARRAY_P, PG_GETARG_INT32, PG_RETURN_INT32, and PG_RETURN_NULL.

ArrayCast()

static Datum ArrayCast ( char *  value, bool  byval, int  len  )

static

Definition at line 4817 of file arrayfuncs.c.

{
    return fetch_att(value, byval, len);
}

References fetch_att(), len, and value.

Referenced by array_get_element().

ArrayCastAndSet()

static int ArrayCastAndSet ( Datum  src, int  typlen, bool  typbyval, char  typalign, char *  dest  )

static

Definition at line 4828 of file arrayfuncs.c.

{
    int         inc;
 
    if (typlen > 0)
    {
        if (typbyval)
            store_att_byval(dest, src, typlen);
        else
            memmove(dest, DatumGetPointer(src), typlen);
        inc = att_align_nominal(typlen, typalign);
    }
    else
    {
        Assert(!typbyval);
        inc = att_addlength_datum(0, typlen, src);
        memmove(dest, DatumGetPointer(src), inc);
        inc = att_align_nominal(inc, typalign);
    }
 
    return inc;
}

References Assert(), att_addlength_datum, att_align_nominal, DatumGetPointer(), generate_unaccent_rules::dest, store_att_byval(), and typalign.

Referenced by array_fill_internal(), array_set_element(), and CopyArrayEls().

arraycontained()

Datum arraycontained

(

PG_FUNCTION_ARGS

)

Definition at line 4561 of file arrayfuncs.c.

{
    AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
    AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
    Oid         collation = PG_GET_COLLATION();
    bool        result;
 
    result = array_contain_compare(array1, array2, collation, true,
                                   &fcinfo->flinfo->fn_extra);
 
    /* Avoid leaking memory when handed toasted input. */
    AARR_FREE_IF_COPY(array1, 0);
    AARR_FREE_IF_COPY(array2, 1);
 
    PG_RETURN_BOOL(result);
}

References AARR_FREE_IF_COPY, array_contain_compare(), PG_GET_COLLATION, PG_GETARG_ANY_ARRAY_P, and PG_RETURN_BOOL.

arraycontains()

Datum arraycontains

(

PG_FUNCTION_ARGS

)

Definition at line 4543 of file arrayfuncs.c.

{
    AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
    AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
    Oid         collation = PG_GET_COLLATION();
    bool        result;
 
    result = array_contain_compare(array2, array1, collation, true,
                                   &fcinfo->flinfo->fn_extra);
 
    /* Avoid leaking memory when handed toasted input. */
    AARR_FREE_IF_COPY(array1, 0);
    AARR_FREE_IF_COPY(array2, 1);
 
    PG_RETURN_BOOL(result);
}

References AARR_FREE_IF_COPY, array_contain_compare(), PG_GET_COLLATION, PG_GETARG_ANY_ARRAY_P, and PG_RETURN_BOOL.

arrayoverlap()

Datum arrayoverlap

(

PG_FUNCTION_ARGS

)

Definition at line 4525 of file arrayfuncs.c.

{
    AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
    AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
    Oid         collation = PG_GET_COLLATION();
    bool        result;
 
    result = array_contain_compare(array1, array2, collation, false,
                                   &fcinfo->flinfo->fn_extra);
 
    /* Avoid leaking memory when handed toasted input. */
    AARR_FREE_IF_COPY(array1, 0);
    AARR_FREE_IF_COPY(array2, 1);
 
    PG_RETURN_BOOL(result);
}

References AARR_FREE_IF_COPY, array_contain_compare(), PG_GET_COLLATION, PG_GETARG_ANY_ARRAY_P, and PG_RETURN_BOOL.

btarraycmp()

Datum btarraycmp

(

PG_FUNCTION_ARGS

)

Definition at line 3974 of file arrayfuncs.c.

{
    PG_RETURN_INT32(array_cmp(fcinfo));
}

References array_cmp(), and PG_RETURN_INT32.

construct_array()

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

Definition at line 3362 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().

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
	)

Definition at line 3382 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, 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(), ts_lexize(), tsvector_to_array(), tsvector_unnest(), typenameTypeMod(), and update_attstats().

construct_empty_array()

ArrayType * construct_empty_array

(

Oid

elmtype

)

Definition at line 3581 of file arrayfuncs.c.

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

References ArrayType::dataoffset, ArrayType::elemtype, ArrayType::ndim, palloc0(), 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
	)

Definition at line 3598 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(), 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
	)

Definition at line 3495 of file arrayfuncs.c.

{
    ArrayType  *result;
    bool        hasnulls;
    int32       nbytes;
    int32       dataoffset;
    int         i;
    int         nelems;
 
    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_align_nominal(nbytes, elmalign);
        /* check for overflow of total request */
        if (!AllocSizeIsValid(nbytes))
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array size exceeds the maximum allowed (%d)",
                            (int) 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_align_nominal, construct_empty_array(), CopyArrayEls(), ArrayType::dataoffset, ArrayType::elemtype, ereport, errcode(), errmsg(), ERROR, i, MaxAllocSize, MAXDIM, ArrayType::ndim, palloc0(), PG_DETOAST_DATUM, PointerGetDatum(), and SET_VARSIZE().

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,
		Datum *	values,
		bool *	nulls,
		int	nitems,
		int	typlen,
		bool	typbyval,
		char	typalign,
		bool	freedata
	)

Definition at line 962 of file arrayfuncs.c.

{
    char       *p = ARR_DATA_PTR(array);
    bits8      *bitmap = ARR_NULLBITMAP(array);
    int         bitval = 0;
    int         bitmask = 1;
    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, typalign, 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, i, nitems, pfree(), typalign, and values.

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

create_array_envelope()

static ArrayType * create_array_envelope ( int  ndims, int *  dimv, int *  lbsv, int  nbytes, Oid  elmtype, int  dataoffset  )

static

Definition at line 6069 of file arrayfuncs.c.

{
    ArrayType  *result;
 
    result = (ArrayType *) palloc0(nbytes);
    SET_VARSIZE(result, nbytes);
    result->ndim = ndims;
    result->dataoffset = dataoffset;
    result->elemtype = elmtype;
    memcpy(ARR_DIMS(result), dimv, ndims * sizeof(int));
    memcpy(ARR_LBOUND(result), lbsv, ndims * sizeof(int));
 
    return result;
}

References ARR_DIMS, ARR_LBOUND, ArrayType::dataoffset, ArrayType::elemtype, ArrayType::ndim, palloc0(), and SET_VARSIZE().

Referenced by array_fill_internal().

deconstruct_array()

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

Definition at line 3632 of file arrayfuncs.c.

{
    Datum      *elems;
    bool       *nulls;
    int         nelems;
    char       *p;
    bits8      *bitmap;
    int         bitmask;
    int         i;
 
    Assert(ARR_ELEMTYPE(array) == elmtype);
 
    nelems = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
    *elemsp = elems = (Datum *) palloc(nelems * sizeof(Datum));
    if (nullsp)
        *nullsp = nulls = (bool *) palloc0(nelems * sizeof(bool));
    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_align_nominal(p, elmalign);
        }
 
        /* 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_align_nominal, ereport, errcode(), errmsg(), ERROR, fetch_att(), i, palloc(), and palloc0().

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	(	ArrayType *	array,
		Oid	elmtype,
		Datum **	elemsp,
		bool **	nullsp,
		int *	nelemsp
	)

Definition at line 3698 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 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, and ERROR.

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(), 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(), textarray_to_stringlist(), textarray_to_strvaluelist(), TidListEval(), transformRelOptions(), tsvector_delete_arr(), tsvector_filter(), tsvector_setweight_by_filter(), untransformRelOptions(), and worker_spi_launch().

generate_subscripts()

Datum generate_subscripts

(

PG_FUNCTION_ARGS

)

Definition at line 5918 of file arrayfuncs.c.

{
    FuncCallContext *funcctx;
    MemoryContext oldcontext;
    generate_subscripts_fctx *fctx;
 
    /* stuff done only on the first call of the function */
    if (SRF_IS_FIRSTCALL())
    {
        AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
        int         reqdim = PG_GETARG_INT32(1);
        int        *lb,
                   *dimv;
 
        /* create a function context for cross-call persistence */
        funcctx = SRF_FIRSTCALL_INIT();
 
        /* Sanity check: does it look like an array at all? */
        if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
            SRF_RETURN_DONE(funcctx);
 
        /* Sanity check: was the requested dim valid */
        if (reqdim <= 0 || reqdim > AARR_NDIM(v))
            SRF_RETURN_DONE(funcctx);
 
        /*
         * switch to memory context appropriate for multiple function calls
         */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
        fctx = (generate_subscripts_fctx *) palloc(sizeof(generate_subscripts_fctx));
 
        lb = AARR_LBOUND(v);
        dimv = AARR_DIMS(v);
 
        fctx->lower = lb[reqdim - 1];
        fctx->upper = dimv[reqdim - 1] + lb[reqdim - 1] - 1;
        fctx->reverse = (PG_NARGS() < 3) ? false : PG_GETARG_BOOL(2);
 
        funcctx->user_fctx = fctx;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    funcctx = SRF_PERCALL_SETUP();
 
    fctx = funcctx->user_fctx;
 
    if (fctx->lower <= fctx->upper)
    {
        if (!fctx->reverse)
            SRF_RETURN_NEXT(funcctx, Int32GetDatum(fctx->lower++));
        else
            SRF_RETURN_NEXT(funcctx, Int32GetDatum(fctx->upper--));
    }
    else
        /* done when there are no more elements left */
        SRF_RETURN_DONE(funcctx);
}

References AARR_DIMS, AARR_LBOUND, AARR_NDIM, Int32GetDatum(), generate_subscripts_fctx::lower, MAXDIM, MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, palloc(), PG_GETARG_ANY_ARRAY_P, PG_GETARG_BOOL, PG_GETARG_INT32, PG_NARGS, generate_subscripts_fctx::reverse, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, generate_subscripts_fctx::upper, and FuncCallContext::user_fctx.

Referenced by generate_subscripts_nodir().

generate_subscripts_nodir()

Datum generate_subscripts_nodir

(

PG_FUNCTION_ARGS

)

Definition at line 5982 of file arrayfuncs.c.

{
    /* just call the other one -- it can handle both cases */
    return generate_subscripts(fcinfo);
}

References generate_subscripts().

hash_array()

Datum hash_array

(

PG_FUNCTION_ARGS

)

Definition at line 4159 of file arrayfuncs.c.

{
    LOCAL_FCINFO(locfcinfo, 1);
    AnyArrayType *array = PG_GETARG_ANY_ARRAY_P(0);
    int         ndims = AARR_NDIM(array);
    int        *dims = AARR_DIMS(array);
    Oid         element_type = AARR_ELEMTYPE(array);
    uint32      result = 1;
    int         nitems;
    TypeCacheEntry *typentry;
    int         typlen;
    bool        typbyval;
    char        typalign;
    int         i;
    array_iter  iter;
 
    /*
     * We arrange to look up the hash function only once per series of calls,
     * assuming the element type doesn't change underneath us.  The typcache
     * is used so that we have no memory leakage when being used as an index
     * support function.
     */
    typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
    if (typentry == NULL ||
        typentry->type_id != element_type)
    {
        typentry = lookup_type_cache(element_type,
                                     TYPECACHE_HASH_PROC_FINFO);
        if (!OidIsValid(typentry->hash_proc_finfo.fn_oid) && element_type != RECORDOID)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("could not identify a hash function for type %s",
                            format_type_be(element_type))));
 
        /*
         * The type cache doesn't believe that record is hashable (see
         * cache_record_field_properties()), but since we're here, we're
         * committed to hashing, so we can assume it does.  Worst case, if any
         * components of the record don't support hashing, we will fail at
         * execution.
         */
        if (element_type == RECORDOID)
        {
            MemoryContext oldcontext;
            TypeCacheEntry *record_typentry;
 
            oldcontext = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
 
            /*
             * Make fake type cache entry structure.  Note that we can't just
             * modify typentry, since that points directly into the type
             * cache.
             */
            record_typentry = palloc0(sizeof(*record_typentry));
            record_typentry->type_id = element_type;
 
            /* fill in what we need below */
            record_typentry->typlen = typentry->typlen;
            record_typentry->typbyval = typentry->typbyval;
            record_typentry->typalign = typentry->typalign;
            fmgr_info(F_HASH_RECORD, &record_typentry->hash_proc_finfo);
 
            MemoryContextSwitchTo(oldcontext);
 
            typentry = record_typentry;
        }
 
        fcinfo->flinfo->fn_extra = typentry;
    }
 
    typlen = typentry->typlen;
    typbyval = typentry->typbyval;
    typalign = typentry->typalign;
 
    /*
     * apply the hash function to each array element.
     */
    InitFunctionCallInfoData(*locfcinfo, &typentry->hash_proc_finfo, 1,
                             PG_GET_COLLATION(), NULL, NULL);
 
    /* Loop over source data */
    nitems = ArrayGetNItems(ndims, dims);
    array_iter_setup(&iter, array);
 
    for (i = 0; i < nitems; i++)
    {
        Datum       elt;
        bool        isnull;
        uint32      elthash;
 
        /* Get element, checking for NULL */
        elt = array_iter_next(&iter, &isnull, i, typlen, typbyval, typalign);
 
        if (isnull)
        {
            /* Treat nulls as having hashvalue 0 */
            elthash = 0;
        }
        else
        {
            /* Apply the hash function */
            locfcinfo->args[0].value = elt;
            locfcinfo->args[0].isnull = false;
            elthash = DatumGetUInt32(FunctionCallInvoke(locfcinfo));
            /* We don't expect hash functions to return null */
            Assert(!locfcinfo->isnull);
        }
 
        /*
         * Combine hash values of successive elements by multiplying the
         * current value by 31 and adding on the new element's hash value.
         *
         * The result is a sum in which each element's hash value is
         * multiplied by a different power of 31. This is modulo 2^32
         * arithmetic, and the powers of 31 modulo 2^32 form a cyclic group of
         * order 2^27. So for arrays of up to 2^27 elements, each element's
         * hash value is multiplied by a different (odd) number, resulting in
         * a good mixing of all the elements' hash values.
         */
        result = (result << 5) - result + elthash;
    }
 
    /* Avoid leaking memory when handed toasted input. */
    AARR_FREE_IF_COPY(array, 0);
 
    PG_RETURN_UINT32(result);
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_FREE_IF_COPY, AARR_NDIM, array_iter_next(), array_iter_setup(), ArrayGetNItems(), Assert(), DatumGetUInt32(), ereport, errcode(), errmsg(), ERROR, fmgr_info(), FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, TypeCacheEntry::hash_proc_finfo, i, if(), InitFunctionCallInfoData, LOCAL_FCINFO, lookup_type_cache(), MemoryContextSwitchTo(), nitems, OidIsValid, palloc0(), PG_GET_COLLATION, PG_GETARG_ANY_ARRAY_P, PG_RETURN_UINT32, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_HASH_PROC_FINFO, and TypeCacheEntry::typlen.

hash_array_extended()

Datum hash_array_extended

(

PG_FUNCTION_ARGS

)

Definition at line 4292 of file arrayfuncs.c.

{
    LOCAL_FCINFO(locfcinfo, 2);
    AnyArrayType *array = PG_GETARG_ANY_ARRAY_P(0);
    uint64      seed = PG_GETARG_INT64(1);
    int         ndims = AARR_NDIM(array);
    int        *dims = AARR_DIMS(array);
    Oid         element_type = AARR_ELEMTYPE(array);
    uint64      result = 1;
    int         nitems;
    TypeCacheEntry *typentry;
    int         typlen;
    bool        typbyval;
    char        typalign;
    int         i;
    array_iter  iter;
 
    typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
    if (typentry == NULL ||
        typentry->type_id != element_type)
    {
        typentry = lookup_type_cache(element_type,
                                     TYPECACHE_HASH_EXTENDED_PROC_FINFO);
        if (!OidIsValid(typentry->hash_extended_proc_finfo.fn_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("could not identify an extended hash function for type %s",
                            format_type_be(element_type))));
        fcinfo->flinfo->fn_extra = typentry;
    }
    typlen = typentry->typlen;
    typbyval = typentry->typbyval;
    typalign = typentry->typalign;
 
    InitFunctionCallInfoData(*locfcinfo, &typentry->hash_extended_proc_finfo, 2,
                             PG_GET_COLLATION(), NULL, NULL);
 
    /* Loop over source data */
    nitems = ArrayGetNItems(ndims, dims);
    array_iter_setup(&iter, array);
 
    for (i = 0; i < nitems; i++)
    {
        Datum       elt;
        bool        isnull;
        uint64      elthash;
 
        /* Get element, checking for NULL */
        elt = array_iter_next(&iter, &isnull, i, typlen, typbyval, typalign);
 
        if (isnull)
        {
            elthash = 0;
        }
        else
        {
            /* Apply the hash function */
            locfcinfo->args[0].value = elt;
            locfcinfo->args[0].isnull = false;
            locfcinfo->args[1].value = Int64GetDatum(seed);
            locfcinfo->args[1].isnull = false;
            elthash = DatumGetUInt64(FunctionCallInvoke(locfcinfo));
            /* We don't expect hash functions to return null */
            Assert(!locfcinfo->isnull);
        }
 
        result = (result << 5) - result + elthash;
    }
 
    AARR_FREE_IF_COPY(array, 0);
 
    PG_RETURN_UINT64(result);
}

References AARR_DIMS, AARR_ELEMTYPE, AARR_FREE_IF_COPY, AARR_NDIM, array_iter_next(), array_iter_setup(), ArrayGetNItems(), Assert(), DatumGetUInt64(), ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, TypeCacheEntry::hash_extended_proc_finfo, i, if(), InitFunctionCallInfoData, Int64GetDatum(), LOCAL_FCINFO, lookup_type_cache(), nitems, OidIsValid, PG_GET_COLLATION, PG_GETARG_ANY_ARRAY_P, PG_GETARG_INT64, PG_RETURN_UINT64, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_HASH_EXTENDED_PROC_FINFO, and TypeCacheEntry::typlen.

initArrayResult()

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

Definition at line 5294 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 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
	)

Definition at line 5783 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, 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
	)

Definition at line 5505 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, 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
	)

Definition at line 5311 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, 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
	)

Definition at line 5421 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 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
	)

Definition at line 5858 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, makeArrayResultArr(), makeMdArrayResult(), ArrayBuildState::nelems, and ArrayBuildStateAny::scalarstate.

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

makeArrayResultArr()

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

Definition at line 5704 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, 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
	)

Definition at line 5453 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, 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().

ReadArrayBinary()

static void ReadArrayBinary ( StringInfo  buf, int  nitems, FmgrInfo *  receiveproc, Oid  typioparam, int32  typmod, int  typlen, bool  typbyval, char  typalign, Datum *  values, bool *  nulls, bool *  hasnulls, int32 *  nbytes  )

static

Definition at line 1455 of file arrayfuncs.c.

{
    int         i;
    bool        hasnull;
    int32       totbytes;
 
    for (i = 0; i < nitems; i++)
    {
        int         itemlen;
        StringInfoData elem_buf;
 
        /* Get and check the item length */
        itemlen = pq_getmsgint(buf, 4);
        if (itemlen < -1 || itemlen > (buf->len - buf->cursor))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                     errmsg("insufficient data left in message")));
 
        if (itemlen == -1)
        {
            /* -1 length means NULL */
            values[i] = ReceiveFunctionCall(receiveproc, NULL,
                                            typioparam, typmod);
            nulls[i] = true;
            continue;
        }
 
        /*
         * Rather than copying data around, we just initialize a StringInfo
         * pointing to the correct portion of the message buffer.
         */
        initReadOnlyStringInfo(&elem_buf, &buf->data[buf->cursor], itemlen);
 
        buf->cursor += itemlen;
 
        /* Now call the element's receiveproc */
        values[i] = ReceiveFunctionCall(receiveproc, &elem_buf,
                                        typioparam, typmod);
        nulls[i] = false;
 
        /* Trouble if it didn't eat the whole buffer */
        if (elem_buf.cursor != itemlen)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                     errmsg("improper binary format in array element %d",
                            i + 1)));
    }
 
    /*
     * Check for nulls, compute total data space needed
     */
    hasnull = false;
    totbytes = 0;
    for (i = 0; i < nitems; i++)
    {
        if (nulls[i])
            hasnull = true;
        else
        {
            /* let's just make sure data is not toasted */
            if (typlen == -1)
                values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
            totbytes = att_addlength_datum(totbytes, typlen, values[i]);
            totbytes = att_align_nominal(totbytes, typalign);
            /* check for overflow of total request */
            if (!AllocSizeIsValid(totbytes))
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("array size exceeds the maximum allowed (%d)",
                                (int) MaxAllocSize)));
        }
    }
    *hasnulls = hasnull;
    *nbytes = totbytes;
}

References AllocSizeIsValid, att_addlength_datum, att_align_nominal, buf, StringInfoData::cursor, ereport, errcode(), errmsg(), ERROR, i, initReadOnlyStringInfo(), MaxAllocSize, nitems, PG_DETOAST_DATUM, PointerGetDatum(), pq_getmsgint(), ReceiveFunctionCall(), typalign, and values.

Referenced by array_recv().

ReadArrayDimensions()

static bool ReadArrayDimensions ( char **  srcptr, int *  ndim_p, int *  dim, int *  lBound, const char *  origStr, Node *  escontext  )

static

Definition at line 403 of file arrayfuncs.c.

{
    char       *p = *srcptr;
    int         ndim;
 
    /*
     * Dimension info takes the form of one or more [n] or [m:n] items.  This
     * loop iterates once per dimension item.
     */
    ndim = 0;
    for (;;)
    {
        char       *q;
        int         ub;
        int         i;
 
        /*
         * Note: we currently allow whitespace between, but not within,
         * dimension items.
         */
        while (scanner_isspace(*p))
            p++;
        if (*p != '[')
            break;              /* no more dimension items */
        p++;
        if (ndim >= MAXDIM)
            ereturn(escontext, false,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("number of array dimensions exceeds the maximum allowed (%d)",
                            MAXDIM)));
 
        q = p;
        if (!ReadDimensionInt(&p, &i, origStr, escontext))
            return false;
        if (p == q)             /* no digits? */
            ereturn(escontext, false,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", origStr),
                     errdetail("\"[\" must introduce explicitly-specified array dimensions.")));
 
        if (*p == ':')
        {
            /* [m:n] format */
            lBound[ndim] = i;
            p++;
            q = p;
            if (!ReadDimensionInt(&p, &ub, origStr, escontext))
                return false;
            if (p == q)         /* no digits? */
                ereturn(escontext, false,
                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                         errmsg("malformed array literal: \"%s\"", origStr),
                         errdetail("Missing array dimension value.")));
        }
        else
        {
            /* [n] format */
            lBound[ndim] = 1;
            ub = i;
        }
        if (*p != ']')
            ereturn(escontext, false,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", origStr),
                     errdetail("Missing \"%s\" after array dimensions.",
                               "]")));
        p++;
 
        /*
         * Note: we could accept ub = lb-1 to represent a zero-length
         * dimension.  However, that would result in an empty array, for which
         * we don't keep any dimension data, so that e.g. [1:0] and [101:100]
         * would be equivalent.  Given the lack of field demand, there seems
         * little point in allowing such cases.
         */
        if (ub < lBound[ndim])
            ereturn(escontext, false,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("upper bound cannot be less than lower bound")));
 
        /* Upper bound of INT_MAX must be disallowed, cf ArrayCheckBounds() */
        if (ub == INT_MAX)
            ereturn(escontext, false,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array upper bound is too large: %d", ub)));
 
        /* Compute "ub - lBound[ndim] + 1", detecting overflow */
        if (pg_sub_s32_overflow(ub, lBound[ndim], &ub) ||
            pg_add_s32_overflow(ub, 1, &ub))
            ereturn(escontext, false,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("array size exceeds the maximum allowed (%d)",
                            (int) MaxArraySize)));
 
        dim[ndim] = ub;
        ndim++;
    }
 
    *srcptr = p;
    *ndim_p = ndim;
    return true;
}

References ereturn, errcode(), errdetail(), errmsg(), i, MaxArraySize, MAXDIM, pg_add_s32_overflow(), pg_sub_s32_overflow(), ReadDimensionInt(), and scanner_isspace().

Referenced by array_in().

ReadArrayStr()

static bool ReadArrayStr ( char **  srcptr, FmgrInfo *  inputproc, Oid  typioparam, int32  typmod, char  typdelim, int  typlen, bool  typbyval, char  typalign, int *  ndim_p, int *  dim, int *  nitems_p, Datum **  values_p, bool **  nulls_p, const char *  origStr, Node *  escontext  )

static

Definition at line 580 of file arrayfuncs.c.

{
    int         ndim = *ndim_p;
    bool        dimensions_specified = (ndim != 0);
    int         maxitems;
    Datum      *values;
    bool       *nulls;
    StringInfoData elembuf;
    int         nest_level;
    int         nitems;
    bool        ndim_frozen;
    bool        expect_delim;
    int         nelems[MAXDIM];
 
    /* Allocate some starting output workspace; we'll enlarge as needed */
    maxitems = 16;
    values = palloc_array(Datum, maxitems);
    nulls = palloc_array(bool, maxitems);
 
    /* Allocate workspace to hold (string representation of) one element */
    initStringInfo(&elembuf);
 
    /* Loop below assumes first token is ATOK_LEVEL_START */
    Assert(**srcptr == '{');
 
    /* Parse tokens until we reach the matching right brace */
    nest_level = 0;
    nitems = 0;
    ndim_frozen = dimensions_specified;
    expect_delim = false;
    do
    {
        ArrayToken  tok;
 
        tok = ReadArrayToken(srcptr, &elembuf, typdelim, origStr, escontext);
 
        switch (tok)
        {
            case ATOK_LEVEL_START:
                /* Can't write left brace where delim is expected */
                if (expect_delim)
                    ereturn(escontext, false,
                            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                             errmsg("malformed array literal: \"%s\"", origStr),
                             errdetail("Unexpected \"%c\" character.", '{')));
 
                /* Initialize element counting in the new level */
                if (nest_level >= MAXDIM)
                    ereturn(escontext, false,
                            (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                             errmsg("number of array dimensions exceeds the maximum allowed (%d)",
                                    MAXDIM)));
 
                nelems[nest_level] = 0;
                nest_level++;
                if (nest_level > ndim)
                {
                    /* Can't increase ndim once it's frozen */
                    if (ndim_frozen)
                        goto dimension_error;
                    ndim = nest_level;
                }
                break;
 
            case ATOK_LEVEL_END:
                /* Can't get here with nest_level == 0 */
                Assert(nest_level > 0);
 
                /*
                 * We allow a right brace to terminate an empty sub-array,
                 * otherwise it must occur where we expect a delimiter.
                 */
                if (nelems[nest_level - 1] > 0 && !expect_delim)
                    ereturn(escontext, false,
                            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                             errmsg("malformed array literal: \"%s\"", origStr),
                             errdetail("Unexpected \"%c\" character.",
                                       '}')));
                nest_level--;
                /* Nested sub-arrays count as elements of outer level */
                if (nest_level > 0)
                    nelems[nest_level - 1]++;
 
                /*
                 * Note: if we had dimensionality info, then dim[nest_level]
                 * is initially non-negative, and we'll check each sub-array's
                 * length against that.
                 */
                if (dim[nest_level] < 0)
                {
                    /* Save length of first sub-array of this level */
                    dim[nest_level] = nelems[nest_level];
                }
                else if (nelems[nest_level] != dim[nest_level])
                {
                    /* Subsequent sub-arrays must have same length */
                    goto dimension_error;
                }
 
                /*
                 * Must have a delim or another right brace following, unless
                 * we have reached nest_level 0, where this won't matter.
                 */
                expect_delim = true;
                break;
 
            case ATOK_DELIM:
                if (!expect_delim)
                    ereturn(escontext, false,
                            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                             errmsg("malformed array literal: \"%s\"", origStr),
                             errdetail("Unexpected \"%c\" character.",
                                       typdelim)));
                expect_delim = false;
                break;
 
            case ATOK_ELEM:
            case ATOK_ELEM_NULL:
                /* Can't get here with nest_level == 0 */
                Assert(nest_level > 0);
 
                /* Disallow consecutive ELEM tokens */
                if (expect_delim)
                    ereturn(escontext, false,
                            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                             errmsg("malformed array literal: \"%s\"", origStr),
                             errdetail("Unexpected array element.")));
 
                /* Enlarge the values/nulls arrays if needed */
                if (nitems >= maxitems)
                {
                    if (maxitems >= MaxArraySize)
                        ereturn(escontext, false,
                                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                                 errmsg("array size exceeds the maximum allowed (%d)",
                                        (int) MaxArraySize)));
                    maxitems = Min(maxitems * 2, MaxArraySize);
                    values = repalloc_array(values, Datum, maxitems);
                    nulls = repalloc_array(nulls, bool, maxitems);
                }
 
                /* Read the element's value, or check that NULL is allowed */
                if (!InputFunctionCallSafe(inputproc,
                                           (tok == ATOK_ELEM_NULL) ? NULL : elembuf.data,
                                           typioparam, typmod,
                                           escontext,
                                           &values[nitems]))
                    return false;
                nulls[nitems] = (tok == ATOK_ELEM_NULL);
                nitems++;
 
                /*
                 * Once we have found an element, the number of dimensions can
                 * no longer increase, and subsequent elements must all be at
                 * the same nesting depth.
                 */
                ndim_frozen = true;
                if (nest_level != ndim)
                    goto dimension_error;
                /* Count the new element */
                nelems[nest_level - 1]++;
 
                /* Must have a delim or a right brace following */
                expect_delim = true;
                break;
 
            case ATOK_ERROR:
                return false;
        }
    } while (nest_level > 0);
 
    /* Clean up and return results */
    pfree(elembuf.data);
 
    *ndim_p = ndim;
    *nitems_p = nitems;
    *values_p = values;
    *nulls_p = nulls;
    return true;
 
dimension_error:
    if (dimensions_specified)
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed array literal: \"%s\"", origStr),
                 errdetail("Specified array dimensions do not match array contents.")));
    else
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed array literal: \"%s\"", origStr),
                 errdetail("Multidimensional arrays must have sub-arrays with matching dimensions.")));
}

References Assert(), ATOK_DELIM, ATOK_ELEM, ATOK_ELEM_NULL, ATOK_ERROR, ATOK_LEVEL_END, ATOK_LEVEL_START, StringInfoData::data, ereturn, errcode(), errdetail(), errmsg(), initStringInfo(), InputFunctionCallSafe(), MaxArraySize, MAXDIM, Min, nitems, palloc_array, pfree(), ReadArrayToken(), repalloc_array, and values.

Referenced by array_in().

ReadArrayToken()

static ArrayToken ReadArrayToken ( char **  srcptr, StringInfo  elembuf, char  typdelim, const char *  origStr, Node *  escontext  )

static

Definition at line 797 of file arrayfuncs.c.

{
    char       *p = *srcptr;
    int         dstlen;
    bool        has_escapes;
 
    resetStringInfo(elembuf);
 
    /* Identify token type.  Loop advances over leading whitespace. */
    for (;;)
    {
        switch (*p)
        {
            case '\0':
                goto ending_error;
            case '{':
                *srcptr = p + 1;
                return ATOK_LEVEL_START;
            case '}':
                *srcptr = p + 1;
                return ATOK_LEVEL_END;
            case '"':
                p++;
                goto quoted_element;
            default:
                if (*p == typdelim)
                {
                    *srcptr = p + 1;
                    return ATOK_DELIM;
                }
                if (scanner_isspace(*p))
                {
                    p++;
                    continue;
                }
                goto unquoted_element;
        }
    }
 
quoted_element:
    for (;;)
    {
        switch (*p)
        {
            case '\0':
                goto ending_error;
            case '\\':
                /* Skip backslash, copy next character as-is. */
                p++;
                if (*p == '\0')
                    goto ending_error;
                appendStringInfoChar(elembuf, *p++);
                break;
            case '"':
 
                /*
                 * If next non-whitespace isn't typdelim or a brace, complain
                 * about incorrect quoting.  While we could leave such cases
                 * to be detected as incorrect token sequences, the resulting
                 * message wouldn't be as helpful.  (We could also give the
                 * incorrect-quoting error when next is '{', but treating that
                 * as a token sequence error seems better.)
                 */
                while (*(++p) != '\0')
                {
                    if (*p == typdelim || *p == '}' || *p == '{')
                    {
                        *srcptr = p;
                        return ATOK_ELEM;
                    }
                    if (!scanner_isspace(*p))
                        ereturn(escontext, ATOK_ERROR,
                                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                 errmsg("malformed array literal: \"%s\"", origStr),
                                 errdetail("Incorrectly quoted array element.")));
                }
                goto ending_error;
            default:
                appendStringInfoChar(elembuf, *p++);
                break;
        }
    }
 
unquoted_element:
 
    /*
     * We don't include trailing whitespace in the result.  dstlen tracks how
     * much of the output string is known to not be trailing whitespace.
     */
    dstlen = 0;
    has_escapes = false;
    for (;;)
    {
        switch (*p)
        {
            case '\0':
                goto ending_error;
            case '{':
                ereturn(escontext, ATOK_ERROR,
                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                         errmsg("malformed array literal: \"%s\"", origStr),
                         errdetail("Unexpected \"%c\" character.",
                                   '{')));
            case '"':
                /* Must double-quote all or none of an element. */
                ereturn(escontext, ATOK_ERROR,
                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                         errmsg("malformed array literal: \"%s\"", origStr),
                         errdetail("Incorrectly quoted array element.")));
            case '\\':
                /* Skip backslash, copy next character as-is. */
                p++;
                if (*p == '\0')
                    goto ending_error;
                appendStringInfoChar(elembuf, *p++);
                dstlen = elembuf->len;  /* treat it as non-whitespace */
                has_escapes = true;
                break;
            default:
                /* End of elem? */
                if (*p == typdelim || *p == '}')
                {
                    /* hack: truncate the output string to dstlen */
                    elembuf->data[dstlen] = '\0';
                    elembuf->len = dstlen;
                    *srcptr = p;
                    /* Check if it's unquoted "NULL" */
                    if (Array_nulls && !has_escapes &&
                        pg_strcasecmp(elembuf->data, "NULL") == 0)
                        return ATOK_ELEM_NULL;
                    else
                        return ATOK_ELEM;
                }
                appendStringInfoChar(elembuf, *p);
                if (!scanner_isspace(*p))
                    dstlen = elembuf->len;
                p++;
                break;
        }
    }
 
ending_error:
    ereturn(escontext, ATOK_ERROR,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("malformed array literal: \"%s\"", origStr),
             errdetail("Unexpected end of input.")));
}

References appendStringInfoChar(), Array_nulls, ATOK_DELIM, ATOK_ELEM, ATOK_ELEM_NULL, ATOK_ERROR, ATOK_LEVEL_END, ATOK_LEVEL_START, StringInfoData::data, ereturn, errcode(), errdetail(), errmsg(), StringInfoData::len, pg_strcasecmp(), resetStringInfo(), and scanner_isspace().

Referenced by ReadArrayStr().

ReadDimensionInt()

static bool ReadDimensionInt ( char **  srcptr, int *  result, const char *  origStr, Node *  escontext  )

static

Definition at line 520 of file arrayfuncs.c.

{
    char       *p = *srcptr;
    long        l;
 
    /* don't accept leading whitespace */
    if (!isdigit((unsigned char) *p) && *p != '-' && *p != '+')
    {
        *result = 0;
        return true;
    }
 
    errno = 0;
    l = strtol(p, srcptr, 10);
 
    if (errno == ERANGE || l > PG_INT32_MAX || l < PG_INT32_MIN)
        ereturn(escontext, false,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("array bound is out of integer range")));
 
    *result = (int) l;
    return true;
}

References ereturn, errcode(), errmsg(), PG_INT32_MAX, and PG_INT32_MIN.

Referenced by ReadArrayDimensions().

trim_array()

Datum trim_array

(

PG_FUNCTION_ARGS

)

Definition at line 6923 of file arrayfuncs.c.

{
    ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);
    int         n = PG_GETARG_INT32(1);
    int         array_length = (ARR_NDIM(v) > 0) ? ARR_DIMS(v)[0] : 0;
    int16       elmlen;
    bool        elmbyval;
    char        elmalign;
    int         lower[MAXDIM];
    int         upper[MAXDIM];
    bool        lowerProvided[MAXDIM];
    bool        upperProvided[MAXDIM];
    Datum       result;
 
    /* Per spec, throw an error if out of bounds */
    if (n < 0 || n > array_length)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_ELEMENT_ERROR),
                 errmsg("number of elements to trim must be between 0 and %d",
                        array_length)));
 
    /* Set all the bounds as unprovided except the first upper bound */
    memset(lowerProvided, false, sizeof(lowerProvided));
    memset(upperProvided, false, sizeof(upperProvided));
    if (ARR_NDIM(v) > 0)
    {
        upper[0] = ARR_LBOUND(v)[0] + array_length - n - 1;
        upperProvided[0] = true;
    }
 
    /* Fetch the needed information about the element type */
    get_typlenbyvalalign(ARR_ELEMTYPE(v), &elmlen, &elmbyval, &elmalign);
 
    /* Get the slice */
    result = array_get_slice(PointerGetDatum(v), 1,
                             upper, lower, upperProvided, lowerProvided,
                             -1, elmlen, elmbyval, elmalign);
 
    PG_RETURN_DATUM(result);
}

References ARR_DIMS, ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_get_slice(), array_length(), ereport, errcode(), errmsg(), ERROR, get_typlenbyvalalign(), lower(), MAXDIM, PG_GETARG_ARRAYTYPE_P, PG_GETARG_INT32, PG_RETURN_DATUM, PointerGetDatum(), and upper().

width_bucket_array()

Datum width_bucket_array

(

PG_FUNCTION_ARGS

)

Definition at line 6691 of file arrayfuncs.c.

{
    Datum       operand = PG_GETARG_DATUM(0);
    ArrayType  *thresholds = PG_GETARG_ARRAYTYPE_P(1);
    Oid         collation = PG_GET_COLLATION();
    Oid         element_type = ARR_ELEMTYPE(thresholds);
    int         result;
 
    /* Check input */
    if (ARR_NDIM(thresholds) > 1)
        ereport(ERROR,
                (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                 errmsg("thresholds must be one-dimensional array")));
 
    if (array_contains_nulls(thresholds))
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("thresholds array must not contain NULLs")));
 
    /* We have a dedicated implementation for float8 data */
    if (element_type == FLOAT8OID)
        result = width_bucket_array_float8(operand, thresholds);
    else
    {
        TypeCacheEntry *typentry;
 
        /* Cache information about the input type */
        typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
        if (typentry == NULL ||
            typentry->type_id != element_type)
        {
            typentry = lookup_type_cache(element_type,
                                         TYPECACHE_CMP_PROC_FINFO);
            if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("could not identify a comparison function for type %s",
                                format_type_be(element_type))));
            fcinfo->flinfo->fn_extra = typentry;
        }
 
        /*
         * We have separate implementation paths for fixed- and variable-width
         * types, since indexing the array is a lot cheaper in the first case.
         */
        if (typentry->typlen > 0)
            result = width_bucket_array_fixed(operand, thresholds,
                                              collation, typentry);
        else
            result = width_bucket_array_variable(operand, thresholds,
                                                 collation, typentry);
    }
 
    /* Avoid leaking memory when handed toasted input. */
    PG_FREE_IF_COPY(thresholds, 1);
 
    PG_RETURN_INT32(result);
}

References ARR_ELEMTYPE, ARR_NDIM, array_contains_nulls(), TypeCacheEntry::cmp_proc_finfo, ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), if(), lookup_type_cache(), OidIsValid, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_RETURN_INT32, TypeCacheEntry::type_id, TYPECACHE_CMP_PROC_FINFO, TypeCacheEntry::typlen, width_bucket_array_fixed(), width_bucket_array_float8(), and width_bucket_array_variable().

width_bucket_array_fixed()

static int width_bucket_array_fixed ( Datum  operand, ArrayType *  thresholds, Oid  collation, TypeCacheEntry *  typentry  )

static

Definition at line 6798 of file arrayfuncs.c.

{
    LOCAL_FCINFO(locfcinfo, 2);
    char       *thresholds_data;
    int         typlen = typentry->typlen;
    bool        typbyval = typentry->typbyval;
    int         left;
    int         right;
 
    /*
     * Since we know the array contains no NULLs, we can just index it
     * directly.
     */
    thresholds_data = (char *) ARR_DATA_PTR(thresholds);
 
    InitFunctionCallInfoData(*locfcinfo, &typentry->cmp_proc_finfo, 2,
                             collation, NULL, NULL);
 
    /* Find the bucket */
    left = 0;
    right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
    while (left < right)
    {
        int         mid = (left + right) / 2;
        char       *ptr;
        int32       cmpresult;
 
        ptr = thresholds_data + mid * typlen;
 
        locfcinfo->args[0].value = operand;
        locfcinfo->args[0].isnull = false;
        locfcinfo->args[1].value = fetch_att(ptr, typbyval, typlen);
        locfcinfo->args[1].isnull = false;
 
        cmpresult = DatumGetInt32(FunctionCallInvoke(locfcinfo));
 
        /* We don't expect comparison support functions to return null */
        Assert(!locfcinfo->isnull);
 
        if (cmpresult < 0)
            right = mid;
        else
            left = mid + 1;
    }
 
    return left;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, ArrayGetNItems(), Assert(), TypeCacheEntry::cmp_proc_finfo, DatumGetInt32(), fetch_att(), FunctionCallInvoke, InitFunctionCallInfoData, LOCAL_FCINFO, TypeCacheEntry::typbyval, and TypeCacheEntry::typlen.

Referenced by width_bucket_array().

width_bucket_array_float8()

static int width_bucket_array_float8 ( Datum  operand, ArrayType *  thresholds  )

static

Definition at line 6754 of file arrayfuncs.c.

{
    float8      op = DatumGetFloat8(operand);
    float8     *thresholds_data;
    int         left;
    int         right;
 
    /*
     * Since we know the array contains no NULLs, we can just index it
     * directly.
     */
    thresholds_data = (float8 *) ARR_DATA_PTR(thresholds);
 
    left = 0;
    right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
 
    /*
     * If the probe value is a NaN, it's greater than or equal to all possible
     * threshold values (including other NaNs), so we need not search.  Note
     * that this would give the same result as searching even if the array
     * contains multiple NaNs (as long as they're correctly sorted), since the
     * loop logic will find the rightmost of multiple equal threshold values.
     */
    if (isnan(op))
        return right;
 
    /* Find the bucket */
    while (left < right)
    {
        int         mid = (left + right) / 2;
 
        if (isnan(thresholds_data[mid]) || op < thresholds_data[mid])
            right = mid;
        else
            left = mid + 1;
    }
 
    return left;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, ArrayGetNItems(), and DatumGetFloat8().

Referenced by width_bucket_array().

width_bucket_array_variable()

static int width_bucket_array_variable ( Datum  operand, ArrayType *  thresholds, Oid  collation, TypeCacheEntry *  typentry  )

static

Definition at line 6853 of file arrayfuncs.c.

{
    LOCAL_FCINFO(locfcinfo, 2);
    char       *thresholds_data;
    int         typlen = typentry->typlen;
    bool        typbyval = typentry->typbyval;
    char        typalign = typentry->typalign;
    int         left;
    int         right;
 
    thresholds_data = (char *) ARR_DATA_PTR(thresholds);
 
    InitFunctionCallInfoData(*locfcinfo, &typentry->cmp_proc_finfo, 2,
                             collation, NULL, NULL);
 
    /* Find the bucket */
    left = 0;
    right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
    while (left < right)
    {
        int         mid = (left + right) / 2;
        char       *ptr;
        int         i;
        int32       cmpresult;
 
        /* Locate mid'th array element by advancing from left element */
        ptr = thresholds_data;
        for (i = left; i < mid; i++)
        {
            ptr = att_addlength_pointer(ptr, typlen, ptr);
            ptr = (char *) att_align_nominal(ptr, typalign);
        }
 
        locfcinfo->args[0].value = operand;
        locfcinfo->args[0].isnull = false;
        locfcinfo->args[1].value = fetch_att(ptr, typbyval, typlen);
        locfcinfo->args[1].isnull = false;
 
        cmpresult = DatumGetInt32(FunctionCallInvoke(locfcinfo));
 
        /* We don't expect comparison support functions to return null */
        Assert(!locfcinfo->isnull);
 
        if (cmpresult < 0)
            right = mid;
        else
        {
            left = mid + 1;
 
            /*
             * Move the thresholds pointer to match new "left" index, so we
             * don't have to seek over those elements again.  This trick
             * ensures we do only O(N) array indexing work, not O(N^2).
             */
            ptr = att_addlength_pointer(ptr, typlen, ptr);
            thresholds_data = (char *) att_align_nominal(ptr, typalign);
        }
    }
 
    return left;
}

References ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, ArrayGetNItems(), Assert(), att_addlength_pointer, att_align_nominal, TypeCacheEntry::cmp_proc_finfo, DatumGetInt32(), fetch_att(), FunctionCallInvoke, i, InitFunctionCallInfoData, LOCAL_FCINFO, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, and TypeCacheEntry::typlen.

Referenced by width_bucket_array().

Variable Documentation

Array_nulls

bool Array_nulls = true

Definition at line 44 of file arrayfuncs.c.

Referenced by ReadArrayToken().