arrayfuncs.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <math.h>
#include "access/htup_details.h"
#include "catalog/pg_type.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	ArrayParseState {   ARRAY_NO_LEVEL , ARRAY_LEVEL_STARTED , ARRAY_ELEM_STARTED , ARRAY_ELEM_COMPLETED ,   ARRAY_QUOTED_ELEM_STARTED , ARRAY_QUOTED_ELEM_COMPLETED , ARRAY_ELEM_DELIMITED , ARRAY_LEVEL_COMPLETED ,   ARRAY_LEVEL_DELIMITED }

Functions
static int	ArrayCount (const char *str, int *dim, char typdelim, Node *escontext)
static bool	ReadArrayStr (char *arrayStr, const char *origStr, int nitems, int ndim, int *dim, FmgrInfo *inputproc, Oid typioparam, int32 typmod, char typdelim, int typlen, bool typbyval, char typalign, Datum *values, bool *nulls, bool *hasnulls, int32 *nbytes, 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 50 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 48 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

ArrayParseState

enum ArrayParseState

Enumerator
ARRAY_NO_LEVEL
ARRAY_LEVEL_STARTED
ARRAY_ELEM_STARTED
ARRAY_ELEM_COMPLETED
ARRAY_QUOTED_ELEM_STARTED
ARRAY_QUOTED_ELEM_COMPLETED
ARRAY_ELEM_DELIMITED
ARRAY_LEVEL_COMPLETED
ARRAY_LEVEL_DELIMITED

Definition at line 56 of file arrayfuncs.c.

{
    ARRAY_NO_LEVEL,
    ARRAY_LEVEL_STARTED,
    ARRAY_ELEM_STARTED,
    ARRAY_ELEM_COMPLETED,
    ARRAY_QUOTED_ELEM_STARTED,
    ARRAY_QUOTED_ELEM_COMPLETED,
    ARRAY_ELEM_DELIMITED,
    ARRAY_LEVEL_COMPLETED,
    ARRAY_LEVEL_DELIMITED
} ArrayParseState;

Function Documentation

accumArrayResult()

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

Definition at line 5297 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 5774 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 ExecScanSubPlan(), and ExecSetParamPlan().

accumArrayResultArr()

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

Definition at line 5497 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 4913 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 1804 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 3932 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 = (void *) 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 4328 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 = (void *) 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 3714 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_columns_length(), 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_tid_array(), and width_bucket_array().

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 4883 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 4544 of file arrayfuncs.c.

{
    ArrayIterator iterator = palloc0(sizeof(ArrayIteratorData));
 
    /*
     * Sanity-check inputs --- caller should have got this right already
     */
    Assert(PointerIsValid(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(), PointerIsValid, 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(), and exec_stmt_foreach_a().

array_dims()

Datum array_dims

(

PG_FUNCTION_ARGS

)

Definition at line 1682 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 3761 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 = (void *) 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(), and CompareOpclassOptions().

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 5044 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 5978 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 6030 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 5937 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 4706 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(), and array_positions().

array_ge()

Datum array_ge

(

PG_FUNCTION_ARGS

)

Definition at line 3914 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 1834 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 1935 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 4728 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 2044 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 3902 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 175 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       *string_save,
               *p;
    int         i,
                nitems;
    Datum      *dataPtr;
    bool       *nullsPtr;
    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;
 
    /* Make a modifiable copy of the input */
    string_save = pstrdup(string);
 
    /*
     * If the input string starts with dimension info, read and use that.
     * Otherwise, we require the input to be in curly-brace style, and we
     * prescan the input to determine dimensions.
     *
     * Dimension info takes the form of one or more [n] or [m:n] items. The
     * outer loop iterates once per dimension item.
     */
    p = string_save;
    ndim = 0;
    for (;;)
    {
        char       *q;
        int         ub;
 
        /*
         * 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, (Datum) 0,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
                            ndim + 1, MAXDIM)));
 
        for (q = p; isdigit((unsigned char) *q) || (*q == '-') || (*q == '+'); q++)
             /* skip */ ;
        if (q == p)             /* no digits? */
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", string),
                     errdetail("\"[\" must introduce explicitly-specified array dimensions.")));
 
        if (*q == ':')
        {
            /* [m:n] format */
            *q = '\0';
            lBound[ndim] = atoi(p);
            p = q + 1;
            for (q = p; isdigit((unsigned char) *q) || (*q == '-') || (*q == '+'); q++)
                 /* skip */ ;
            if (q == p)         /* no digits? */
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                         errmsg("malformed array literal: \"%s\"", string),
                         errdetail("Missing array dimension value.")));
        }
        else
        {
            /* [n] format */
            lBound[ndim] = 1;
        }
        if (*q != ']')
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", string),
                     errdetail("Missing \"%s\" after array dimensions.",
                               "]")));
 
        *q = '\0';
        ub = atoi(p);
        p = q + 1;
        if (ub < lBound[ndim])
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                     errmsg("upper bound cannot be less than lower bound")));
 
        dim[ndim] = ub - lBound[ndim] + 1;
        ndim++;
    }
 
    if (ndim == 0)
    {
        /* No array dimensions, so intuit dimensions from brace structure */
        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.")));
        ndim = ArrayCount(p, dim, typdelim, escontext);
        if (ndim < 0)
            PG_RETURN_NULL();
        for (i = 0; i < ndim; i++)
            lBound[i] = 1;
    }
    else
    {
        int         ndim_braces,
                    dim_braces[MAXDIM];
 
        /* 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);
        while (scanner_isspace(*p))
            p++;
 
        /*
         * intuit dimensions from brace structure -- it better match what we
         * were given
         */
        if (*p != '{')
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", string),
                     errdetail("Array contents must start with \"{\".")));
        ndim_braces = ArrayCount(p, dim_braces, typdelim, escontext);
        if (ndim_braces < 0)
            PG_RETURN_NULL();
        if (ndim_braces != ndim)
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed array literal: \"%s\"", string),
                     errdetail("Specified array dimensions do not match array contents.")));
        for (i = 0; i < ndim; ++i)
        {
            if (dim[i] != dim_braces[i])
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                         errmsg("malformed array literal: \"%s\"", string),
                         errdetail("Specified array dimensions do not match array contents.")));
        }
    }
 
#ifdef ARRAYDEBUG
    printf("array_in- ndim %d (", ndim);
    for (i = 0; i < ndim; i++)
    {
        printf(" %d", dim[i]);
    };
    printf(") for %s\n", string);
#endif
 
    /* This checks for overflow of the array dimensions */
    nitems = ArrayGetNItemsSafe(ndim, dim, escontext);
    if (nitems < 0)
        PG_RETURN_NULL();
    if (!ArrayCheckBoundsSafe(ndim, dim, lBound, escontext))
        PG_RETURN_NULL();
 
    /* Empty array? */
    if (nitems == 0)
        PG_RETURN_ARRAYTYPE_P(construct_empty_array(element_type));
 
    dataPtr = (Datum *) palloc(nitems * sizeof(Datum));
    nullsPtr = (bool *) palloc(nitems * sizeof(bool));
    if (!ReadArrayStr(p, string,
                      nitems, ndim, dim,
                      &my_extra->proc, typioparam, typmod,
                      typdelim,
                      typlen, typbyval, typalign,
                      dataPtr, nullsPtr,
                      &hasnulls, &nbytes, escontext))
        PG_RETURN_NULL();
    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;
 
    /*
     * 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,
                 dataPtr, nullsPtr, nitems,
                 typlen, typbyval, typalign,
                 true);
 
    pfree(dataPtr);
    pfree(nullsPtr);
    pfree(string_save);
 
    PG_RETURN_ARRAYTYPE_P(retval);
}

References ARR_DIMS, ARR_LBOUND, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ArrayCheckBoundsSafe(), ArrayCount(), ArrayGetNItemsSafe(), ASSGN, 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, MAXDIM, MemoryContextAlloc(), ArrayType::ndim, nitems, palloc(), palloc0(), pfree(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_ARRAYTYPE_P, PG_RETURN_NULL, printf, ArrayMetaState::proc, pstrdup(), ReadArrayStr(), scanner_isspace(), SET_VARSIZE, typalign, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, and ArrayMetaState::typlen.

Referenced by extract_variadic_args().

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 5117 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 4623 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(), and exec_stmt_foreach_a().

array_larger()

Datum array_larger

(

PG_FUNCTION_ARGS

)

Definition at line 5832 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 3908 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 1777 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 1720 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 3896 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 3160 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 1666 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 3890 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 4861 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 1019 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 1274 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 3105 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 6581 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 6603 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 6323 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 = (void *) 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 4813 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 1562 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 3122 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 2215 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
     */
    if (ndim == 1)
    {
        if (indx[0] < lb[0])
        {
            addedbefore = lb[0] - indx[0];
            dim[0] += addedbefore;
            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 (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, MAXDIM, ArrayType::ndim, palloc(), palloc0(), PG_DETOAST_DATUM, 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 2499 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 matches original array_set_element)
     */
    if (ndim == 1)
    {
        if (indx[0] < lb[0])
        {
            addedbefore = lb[0] - indx[0];
            dim[0] += addedbefore;
            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;
            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, MAXDIM, MemoryContextAllocZero(), MemoryContextSwitchTo(), ExpandedArrayHeader::ndims, ExpandedArrayHeader::nelems, pfree(), 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 4745 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 2788 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.")));
 
            dim[i] = 1 + upperIndx[i] - lowerIndx[i];
            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
     */
    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])
        {
            if (upperIndx[0] < lb[0] - 1)
                newhasnulls = true; /* will insert nulls */
            addedbefore = lb[0] - lowerIndx[0];
            dim[0] += addedbefore;
            lb[0] = lowerIndx[0];
        }
        if (upperIndx[0] >= (dim[0] + lb[0]))
        {
            if (lowerIndx[0] > (dim[0] + lb[0]))
                newhasnulls = true; /* will insert nulls */
            addedafter = upperIndx[0] - (dim[0] + lb[0]) + 1;
            dim[0] += addedafter;
        }
    }
    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, MAXDIM, mda_get_range(), Min, ArrayType::ndim, nitems, palloc0(), 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 4984 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 5841 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 6199 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 6287 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(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 1747 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 4763 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 4774 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 4507 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,