#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 "utils/array.h"
#include "utils/arrayaccess.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/typcache.h"

Include dependency graph for arrayfuncs.c:

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 bool	array_isspace (char ch)

static int	ArrayCount (const char str, int dim, char typdelim)

static void	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)

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 lbv, 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, 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, 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 (FunctionCallInfo fcinfo, Oid retType, ArrayMapState *amstate)

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

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)

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)

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 *	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_remove (PG_FUNCTION_ARGS)

Datum	array_replace (PG_FUNCTION_ARGS)

Datum	width_bucket_array (PG_FUNCTION_ARGS)

Variables
bool	Array_nulls = true

Macro Definition Documentation

#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 46 of file arrayfuncs.c.

Referenced by array_cmp(), array_eq(), arraycontained(), arraycontains(), arrayoverlap(), and hash_array().

#define APPENDCHAR ( ch ) (*p++ = (ch), *p = '\0')

Referenced by array_out().

#define APPENDSTR ( str ) (strcpy(p, (str)), p += strlen(p))

Referenced by array_out().

#define ASSGN "="

Definition at line 44 of file arrayfuncs.c.

Referenced by array_in(), and array_out().

Typedef Documentation

typedef struct ArrayIteratorData ArrayIteratorData

typedef struct generate_subscripts_fctx generate_subscripts_fctx

Enumeration Type Documentation

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 52 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

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

Definition at line 4964 of file arrayfuncs.c.

References ArrayBuildState::alen, Assert, datumCopy(), ArrayBuildState::dnulls, ArrayBuildState::dvalues, ArrayBuildState::element_type, initArrayResult(), ArrayBuildState::mcontext, MemoryContextSwitchTo(), ArrayBuildState::nelems, NULL, PG_DETOAST_DATUM_COPY, PointerGetDatum, repalloc(), ArrayBuildState::typbyval, and ArrayBuildState::typlen.

Referenced by accumArrayResultAny(), array_agg_transfn(), array_positions(), array_to_datum_internal(), dblink_get_connections(), get_altertable_subcmdtypes(), optionListToArray(), regexp_split_to_array(), text_to_array_internal(), and transformRelOptions().

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

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

Definition at line 5438 of file arrayfuncs.c.

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

Referenced by ExecScanSubPlan(), and ExecSetParamPlan().

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

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

Definition at line 5161 of file arrayfuncs.c.

Referenced by accumArrayResultAny(), and array_agg_array_transfn().

 {
     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 = 1024;
         while (astate->abytes <= ndatabytes)
             astate->abytes *= 2;
         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 = 256;
             while (astate->aitems <= newnitems)
                 astate->aitems *= 2;
             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;
 }

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

Definition at line 4595 of file arrayfuncs.c.

References Assert.

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

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

Datum array_cardinality ( PG_FUNCTION_ARGS )

Definition at line 1776 of file arrayfuncs.c.

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

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

static int array_cmp ( FunctionCallInfo fcinfo )

static

Definition at line 3731 of file arrayfuncs.c.

References AARR_DIMS, AARR_ELEMTYPE, AARR_FREE_IF_COPY, AARR_LBOUND, AARR_NDIM, FunctionCallInfoData::arg, FunctionCallInfoData::argnull, array_iter_next(), array_iter_setup(), ArrayGetNItems(), TypeCacheEntry::cmp_proc_finfo, DatumGetInt32, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, i, InitFunctionCallInfoData, FunctionCallInfoData::isnull, lookup_type_cache(), Min, NULL, OidIsValid, PG_GET_COLLATION, PG_GETARG_ANY_ARRAY, 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().

 {
     AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
     AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(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;
     FunctionCallInfoData locfcinfo;
 
     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.arg[0] = elt1;
         locfcinfo.arg[1] = elt2;
         locfcinfo.argnull[0] = false;
         locfcinfo.argnull[1] = false;
         locfcinfo.isnull = false;
         cmpresult = DatumGetInt32(FunctionCallInvoke(&locfcinfo));
 
         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;
 }

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

static

Definition at line 4010 of file arrayfuncs.c.

References AARR_DIMS, AARR_ELEMTYPE, AARR_NDIM, FunctionCallInfoData::arg, FunctionCallInfoData::argnull, 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, AnyArrayType::flt, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, i, InitFunctionCallInfoData, FunctionCallInfoData::isnull, lookup_type_cache(), ExpandedArrayHeader::nelems, NULL, OidIsValid, 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().

 {
     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;
     FunctionCallInfoData locfcinfo;
 
     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(&(array2->flt),
                           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
              */
             locfcinfo.arg[0] = elt1;
             locfcinfo.arg[1] = elt2;
             locfcinfo.argnull[0] = false;
             locfcinfo.argnull[1] = false;
             locfcinfo.isnull = false;
             oprresult = DatumGetBool(FunctionCallInvoke(&locfcinfo));
             if (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;
 }

bool array_contains_nulls ( ArrayType * array )

Definition at line 3513 of file arrayfuncs.c.

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

Referenced by _arrq_cons(), _lca(), _lt_q_regex(), _ltree_compress(), array_fill_internal(), array_iterator(), array_position_common(), array_positions(), ArrayGetIntegerTypmods(), arrq_cons(), cube_a_f8(), cube_a_f8_f8(), cube_subset(), get_jsonb_path_all(), get_path_all(), getWeights(), lt_q_regex(), pg_logical_slot_get_changes_guts(), and width_bucket_array().

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

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

static

Definition at line 4565 of file arrayfuncs.c.

References array_nelems_size().

Referenced by array_extract_slice(), and array_insert_slice().

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

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

Definition at line 4226 of file arrayfuncs.c.

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

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

Datum array_dims ( PG_FUNCTION_ARGS )

Definition at line 1654 of file arrayfuncs.c.

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

 {
     AnyArrayType *v = PG_GETARG_ANY_ARRAY(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));
 }

Datum array_eq ( PG_FUNCTION_ARGS )

Definition at line 3560 of file arrayfuncs.c.

References AARR_DIMS, AARR_ELEMTYPE, AARR_FREE_IF_COPY, AARR_LBOUND, AARR_NDIM, FunctionCallInfoData::arg, FunctionCallInfoData::argnull, array_iter_next(), array_iter_setup(), ArrayGetNItems(), DatumGetBool, TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, i, InitFunctionCallInfoData, FunctionCallInfoData::isnull, lookup_type_cache(), NULL, OidIsValid, PG_GET_COLLATION, PG_GETARG_ANY_ARRAY, PG_RETURN_BOOL, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_EQ_OPR_FINFO, and TypeCacheEntry::typlen.

Referenced by array_ne().

 {
     AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
     AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(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;
     FunctionCallInfoData locfcinfo;
 
     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
              */
             locfcinfo.arg[0] = elt1;
             locfcinfo.arg[1] = elt2;
             locfcinfo.argnull[0] = false;
             locfcinfo.argnull[1] = false;
             locfcinfo.isnull = false;
             oprresult = DatumGetBool(FunctionCallInvoke(&locfcinfo));
             if (!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);
 }

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

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

Referenced by array_get_slice().

 {
     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);
 }

Datum array_fill ( PG_FUNCTION_ARGS )

Definition at line 5642 of file arrayfuncs.c.

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

 {
     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);
 }

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

static

Definition at line 5694 of file arrayfuncs.c.

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

Referenced by array_fill(), and array_fill_with_lower_bounds().

 {
     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 (ARR_LBOUND(dims)[0] != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                  errmsg("wrong range of array subscripts"),
                  errdetail("Lower bound of dimension array must be one.")));
 
     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_DIMS(dims)[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 (ARR_LBOUND(lbs)[0] != 1)
             ereport(ERROR,
                     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
                      errmsg("wrong range of array subscripts"),
                   errdetail("Lower bound of dimension array must be one.")));
 
         if (array_contains_nulls(lbs))
             ereport(ERROR,
                     (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                      errmsg("dimension values cannot be null")));
 
         if (ARR_DIMS(lbs)[0] != ndims)
             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;
     }
 
     /* fast track for empty array */
     if (ndims == 0)
         return construct_empty_array(elmtype);
 
     nitems = ArrayGetNItems(ndims, dimv);
 
     /*
      * 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;
 }

Datum array_fill_with_lower_bounds ( PG_FUNCTION_ARGS )

Definition at line 5601 of file arrayfuncs.c.

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.

 {
     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);
 }

void array_free_iterator ( ArrayIterator iterator )

Definition at line 4388 of file arrayfuncs.c.

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

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

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

Datum array_ge ( PG_FUNCTION_ARGS )

Definition at line 3713 of file arrayfuncs.c.

References array_cmp(), and PG_RETURN_BOOL.

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

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

Definition at line 1806 of file arrayfuncs.c.

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, NULL, and VARATT_IS_EXTERNAL_EXPANDED.

Referenced by array_ref(), and ExecEvalArrayRef().

 {
     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);
 }

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

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

 {
     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];
 }

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

static

Definition at line 4410 of file arrayfuncs.c.

References NULL.

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

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

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

Definition at line 2010 of file arrayfuncs.c.

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, NULL, palloc0(), PointerGetDatum, and SET_VARSIZE.

Referenced by ExecEvalArrayRef().

 {
     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 (lowerIndx[i] < lb[i])
             lowerIndx[i] = lb[i];
         if (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);
 }

Datum array_gt ( PG_FUNCTION_ARGS )

Definition at line 3701 of file arrayfuncs.c.

References array_cmp(), and PG_RETURN_BOOL.

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

Datum array_in ( PG_FUNCTION_ARGS )

Definition at line 171 of file arrayfuncs.c.

References ARR_DIMS, ARR_LBOUND, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, array_isspace(), ArrayCount(), ArrayGetNItems(), ASSGN, construct_empty_array(), CopyArrayEls(), ArrayType::dataoffset, ArrayMetaState::element_type, ArrayType::elemtype, ereport, errcode(), errdetail(), errmsg(), ERROR, fmgr_info_cxt(), FmgrInfo::fn_mcxt, get_type_io_data(), i, IOFunc_input, MAXDIM, MemoryContextAlloc(), ArrayType::ndim, NULL, palloc(), palloc0(), pfree(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_ARRAYTYPE_P, ArrayMetaState::proc, pstrdup(), ReadArrayStr(), SET_VARSIZE, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, and ArrayMetaState::typlen.

 {
     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 */
     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 (array_isspace(*p))
             p++;
         if (*p != '[')
             break;              /* no more dimension items */
         p++;
         if (ndim >= MAXDIM)
             ereport(ERROR,
                     (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? */
             ereport(ERROR,
                     (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? */
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                          errmsg("malformed array literal: \"%s\"", string),
                          errdetail("Missing array dimension value.")));
         }
         else
         {
             /* [n] format */
             lBound[ndim] = 1;
         }
         if (*q != ']')
             ereport(ERROR,
                     (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])
             ereport(ERROR,
                     (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 != '{')
             ereport(ERROR,
                     (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);
         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)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                      errmsg("malformed array literal: \"%s\"", string),
                      errdetail("Missing \"%s\" after array dimensions.",
                                ASSGN)));
         p += strlen(ASSGN);
         while (array_isspace(*p))
             p++;
 
         /*
          * intuit dimensions from brace structure -- it better match what we
          * were given
          */
         if (*p != '{')
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                      errmsg("malformed array literal: \"%s\"", string),
                      errdetail("Array contents must start with \"{\".")));
         ndim_braces = ArrayCount(p, dim_braces, typdelim);
         if (ndim_braces != ndim)
             ereport(ERROR,
                     (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])
                 ereport(ERROR,
                         (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 = ArrayGetNItems(ndim, dim);
     /* 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));
     ReadArrayStr(p, string,
                  nitems, ndim, dim,
                  &my_extra->proc, typioparam, typmod,
                  typdelim,
                  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;
 
     /*
      * 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);
 }

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

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

Referenced by array_set_slice().

 {
     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);
 }

static bool array_isspace ( char ch )

static

Definition at line 431 of file arrayfuncs.c.

Referenced by array_in(), array_out(), ArrayCount(), and ReadArrayStr().

 {
     if (ch == ' ' ||
         ch == '\t' ||
         ch == '\n' ||
         ch == '\r' ||
         ch == '\v' ||
         ch == '\f')
         return true;
     return false;
 }

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

Definition at line 4305 of file arrayfuncs.c.

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

 {
     /* 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;
 }

Datum array_larger ( PG_FUNCTION_ARGS )

Definition at line 5496 of file arrayfuncs.c.

References array_cmp(), PG_GETARG_DATUM, and PG_RETURN_DATUM.

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

Datum array_le ( PG_FUNCTION_ARGS )

Definition at line 3707 of file arrayfuncs.c.

References array_cmp(), and PG_RETURN_BOOL.

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

Datum array_length ( PG_FUNCTION_ARGS )

Definition at line 1749 of file arrayfuncs.c.

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

 {
     AnyArrayType *v = PG_GETARG_ANY_ARRAY(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);
 }

Datum array_lower ( PG_FUNCTION_ARGS )

Definition at line 1692 of file arrayfuncs.c.

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

 {
     AnyArrayType *v = PG_GETARG_ANY_ARRAY(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);
 }

Datum array_lt ( PG_FUNCTION_ARGS )

Definition at line 3695 of file arrayfuncs.c.

References array_cmp(), and PG_RETURN_BOOL.

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

Datum array_map	(	FunctionCallInfo	fcinfo,
		Oid	retType,
		ArrayMapState *	amstate
	)

Definition at line 3091 of file arrayfuncs.c.

References AARR_DIMS, AARR_ELEMTYPE, AARR_LBOUND, AARR_NDIM, AllocSizeIsValid, FunctionCallInfoData::arg, FunctionCallInfoData::argnull, 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, ArrayMetaState::element_type, ArrayType::elemtype, elog, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoData::flinfo, FmgrInfo::fn_strict, FunctionCallInvoke, get_typlenbyvalalign(), i, ArrayMapState::inp_extra, FunctionCallInfoData::isnull, MaxAllocSize, FunctionCallInfoData::nargs, ArrayType::ndim, palloc(), palloc0(), pfree(), PG_ARGISNULL, PG_DETOAST_DATUM, PG_GETARG_ANY_ARRAY, PG_RETURN_ARRAYTYPE_P, PointerGetDatum, ArrayMapState::ret_extra, SET_VARSIZE, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typlen, and values.

Referenced by ExecEvalArrayCoerceExpr().

 {
     AnyArrayType *v;
     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;
 
     /* Get input array */
     if (fcinfo->nargs < 1)
         elog(ERROR, "invalid nargs: %d", fcinfo->nargs);
     if (PG_ARGISNULL(0))
         elog(ERROR, "null input array");
     v = PG_GETARG_ANY_ARRAY(0);
 
     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 */
         PG_RETURN_ARRAYTYPE_P(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++)
     {
         bool        callit = true;
 
         /* Get source element, checking for NULL */
         fcinfo->arg[0] = array_iter_next(&iter, &fcinfo->argnull[0], i,
                                      inp_typlen, inp_typbyval, inp_typalign);
 
         /*
          * Apply the given function to source elt and extra args.
          */
         if (fcinfo->flinfo->fn_strict)
         {
             int         j;
 
             for (j = 0; j < fcinfo->nargs; j++)
             {
                 if (fcinfo->argnull[j])
                 {
                     callit = false;
                     break;
                 }
             }
         }
 
         if (callit)
         {
             fcinfo->isnull = false;
             values[i] = FunctionCallInvoke(fcinfo);
         }
         else
             fcinfo->isnull = true;
 
         nulls[i] = fcinfo->isnull;
         if (fcinfo->isnull)
             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 initialize 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));
 
     /*
      * Note: do not risk trying to pfree the results of the called function
      */
     CopyArrayEls(result,
                  values, nulls, nitems,
                  typlen, typbyval, typalign,
                  false);
 
     pfree(values);
     pfree(nulls);
 
     PG_RETURN_ARRAYTYPE_P(result);
 }

Datum array_ndims ( PG_FUNCTION_ARGS )

Definition at line 1638 of file arrayfuncs.c.

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

 {
     AnyArrayType *v = PG_GETARG_ANY_ARRAY(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));
 }

Datum array_ne ( PG_FUNCTION_ARGS )

Definition at line 3689 of file arrayfuncs.c.

References array_eq(), DatumGetBool, and PG_RETURN_BOOL.

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

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

static

Definition at line 4543 of file arrayfuncs.c.

References array_seek().

Referenced by array_copy(), and array_set_slice().

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

Datum array_out ( PG_FUNCTION_ARGS )

Definition at line 1011 of file arrayfuncs.c.

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

Referenced by anyarray_out().

 {
     AnyArrayType *v = PG_GETARG_ANY_ARRAY(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;
     int         nitems,
                 overall_length,
                 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 = 1;         /* don't forget to count \0 at end. */
 
     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 ||
                          array_isspace(ch))
                     needquote = true;
             }
         }
 
         needquotes[i] = needquote;
 
         /* Count the pair of double quotes, if needed */
         if (needquote)
             overall_length += 2;
         /* and the comma */
         overall_length += 1;
     }
 
     /*
      * count total number of curly braces in output string
      */
     for (i = j = 0, k = 1; i < ndim; i++)
         k *= dims[i], j += k;
 
     dims_str[0] = '\0';
 
     /* add explicit dimensions if required */
     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';
     }
 
     retval = (char *) palloc(strlen(dims_str) + overall_length + 2 * j);
     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--)
         {
             indx[i] = (indx[i] + 1) % dims[i];
             if (indx[i])
             {
                 APPENDCHAR(typdelim);
                 break;
             }
             else
                 APPENDCHAR('}');
         }
         j = i;
     } while (j != -1);
 
 #undef APPENDSTR
 #undef APPENDCHAR
 
     pfree(values);
     pfree(needquotes);
 
     PG_RETURN_CSTRING(retval);
 }

Datum array_recv ( PG_FUNCTION_ARGS )

Definition at line 1254 of file arrayfuncs.c.

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

Referenced by int2vectorrecv(), and oidvectorrecv().

 {
     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")));
 
     element_type = pq_getmsgint(buf, sizeof(Oid));
     if (element_type != spec_element_type)
     {
         /* XXX Can we allow taking the input element type in any cases? */
         ereport(ERROR,
                 (errcode(ERRCODE_DATATYPE_MISMATCH),
                  errmsg("wrong element type")));
     }
 
     for (i = 0; i < ndim; i++)
     {
         dim[i] = pq_getmsgint(buf, 4);
         lBound[i] = pq_getmsgint(buf, 4);
 
         /*
          * Check overflow of upper bound. (ArrayNItems() below checks that
          * dim[i] >= 0)
          */
         if (dim[i] != 0)
         {
             int         ub = lBound[i] + dim[i] - 1;
 
             if (lBound[i] > ub)
                 ereport(ERROR,
                         (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                          errmsg("integer out of range")));
         }
     }
 
     /* This checks for overflow of array dimensions */
     nitems = ArrayGetNItems(ndim, dim);
 
     /*
      * 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);
 }

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

Definition at line 3034 of file arrayfuncs.c.

References array_get_element(), and PointerGetDatum.

Referenced by GUCArrayAdd(), GUCArrayDelete(), GUCArrayReset(), pg_get_functiondef(), PLyList_FromArray(), and ProcessGUCArray().

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

Datum array_remove ( PG_FUNCTION_ARGS )

Definition at line 6225 of file arrayfuncs.c.

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

 {
     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);
 }

Datum array_replace ( PG_FUNCTION_ARGS )

Definition at line 6247 of file arrayfuncs.c.

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

 {
     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);
 }

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

References AllocSizeIsValid, FunctionCallInfoData::arg, FunctionCallInfoData::argnull, 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, FunctionCallInfoData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, i, InitFunctionCallInfoData, FunctionCallInfoData::isnull, lookup_type_cache(), MaxAllocSize, ArrayType::ndim, NULL, OidIsValid, palloc(), palloc0(), pfree(), PG_DETOAST_DATUM, PointerGetDatum, SET_VARSIZE, skip(), TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_EQ_OPR_FINFO, TypeCacheEntry::typlen, and values.

Referenced by array_remove(), and array_replace().

 {
     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;
     FunctionCallInfoData locfcinfo;
 
     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
                  */
                 locfcinfo.arg[0] = elt;
                 locfcinfo.arg[1] = search;
                 locfcinfo.argnull[0] = false;
                 locfcinfo.argnull[1] = false;
                 locfcinfo.isnull = false;
                 oprresult = DatumGetBool(FunctionCallInvoke(&locfcinfo));
                 if (!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;
 }

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

static

Definition at line 4495 of file arrayfuncs.c.

References att_addlength_pointer, att_align_nominal, and i.

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

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

Datum array_send ( PG_FUNCTION_ARGS )

Definition at line 1534 of file arrayfuncs.c.

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, IOFunc_send, MemoryContextAlloc(), NULL, OidIsValid, pfree(), PG_GETARG_ANY_ARRAY, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbytes(), pq_sendint(), ArrayMetaState::proc, SendFunctionCall(), ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, ArrayMetaState::typlen, VARDATA, VARHDRSZ, and VARSIZE.

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

 {
     AnyArrayType *v = PG_GETARG_ANY_ARRAY(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_sendint(&buf, ndim, 4);
     pq_sendint(&buf, AARR_HASNULL(v) ? 1 : 0, 4);
     pq_sendint(&buf, element_type, sizeof(Oid));
     for (i = 0; i < ndim; i++)
     {
         pq_sendint(&buf, dim[i], 4);
         pq_sendint(&buf, lb[i], 4);
     }
 
     /* 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_sendint(&buf, -1, 4);
         }
         else
         {
             bytea      *outputbytes;
 
             outputbytes = SendFunctionCall(&my_extra->proc, itemvalue);
             pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
             pq_sendbytes(&buf, VARDATA(outputbytes),
                          VARSIZE(outputbytes) - VARHDRSZ);
             pfree(outputbytes);
         }
     }
 
     PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }

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

Definition at line 3051 of file arrayfuncs.c.

References array_set_element(), DatumGetArrayTypeP, and PointerGetDatum.

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

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

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

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(), 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, MemSet, ArrayType::ndim, palloc(), palloc0(), PG_DETOAST_DATUM, PointerGetDatum, SET_VARSIZE, and VARATT_IS_EXTERNAL_EXPANDED.

Referenced by array_append(), array_prepend(), array_set(), exec_assign_value(), and ExecEvalArrayRef().

 {
     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] * elmlen >= arraytyplen)
             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")));
         }
     }
 
     /*
      * Compute sizes of items and areas to copy
      */
     newnitems = ArrayGetNItems(ndim, dim);
     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);
 
         /* Zero the bitmap to take care of marking inserted positions null */
         MemSet(newnullbitmap, 0, (newnitems + 7) / 8);
         /* 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);
 }

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

Referenced by array_set_element().

 {
     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).  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")));
         }
     }
 
     /* 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);
 }

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

static

Definition at line 4427 of file arrayfuncs.c.

Referenced by array_set_element().

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

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

Definition at line 2734 of file arrayfuncs.c.

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(), ArrayGetNItems(), Assert, construct_md_array(), ArrayType::dataoffset, DatumGetArrayTypeP, deconstruct_array(), ArrayType::elemtype, ereport, errcode(), errmsg(), ERROR, i, Max, MAXDIM, mda_get_range(), MemSet, Min, ArrayType::ndim, palloc0(), PointerGetDatum, and SET_VARSIZE.

Referenced by ExecEvalArrayRef().

 {
     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++)
         {
             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 (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 (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);
 
     /*
      * 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);
 
             /* Zero the bitmap to handle marking inserted positions null */
             MemSet(newnullbitmap, 0, (nitems + 7) / 8);
             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);
 }

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

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

Referenced by array_get_slice(), and array_set_slice().

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

Datum array_smaller ( PG_FUNCTION_ARGS )

Definition at line 5505 of file arrayfuncs.c.

References array_cmp(), PG_GETARG_DATUM, and PG_RETURN_DATUM.

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

Datum array_unnest ( PG_FUNCTION_ARGS )

Definition at line 5873 of file arrayfuncs.c.

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, 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.

 {
     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(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);
     }
 }

Datum array_upper ( PG_FUNCTION_ARGS )

Definition at line 1719 of file arrayfuncs.c.

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

 {
     AnyArrayType *v = PG_GETARG_ANY_ARRAY(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);
 }

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

static

Definition at line 4445 of file arrayfuncs.c.

References fetch_att.

Referenced by array_get_element().

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

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

static

Definition at line 4456 of file arrayfuncs.c.

References Assert, att_addlength_datum, att_align_nominal, DatumGetPointer, memmove, and store_att_byval.

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

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

Datum arraycontained ( PG_FUNCTION_ARGS )

Definition at line 4189 of file arrayfuncs.c.

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

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

Datum arraycontains ( PG_FUNCTION_ARGS )

Definition at line 4171 of file arrayfuncs.c.

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

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

static int ArrayCount	(	const char *	str,
		int *	dim,
		char	typdelim
	)

static

Definition at line 451 of file arrayfuncs.c.

References ARRAY_ELEM_COMPLETED, ARRAY_ELEM_DELIMITED, ARRAY_ELEM_STARTED, array_isspace(), ARRAY_LEVEL_COMPLETED, ARRAY_LEVEL_DELIMITED, ARRAY_LEVEL_STARTED, ARRAY_NO_LEVEL, ARRAY_QUOTED_ELEM_COMPLETED, ARRAY_QUOTED_ELEM_STARTED, ereport, errcode(), errdetail(), errmsg(), ERROR, i, and MAXDIM.

Referenced by array_in().

 {
     int         nest_level = 0,
                 i;
     int         ndim = 1,
                 temp[MAXDIM],
                 nelems[MAXDIM],
                 nelems_last[MAXDIM];
     bool        in_quotes = false;
     bool        eoArray = false;
     bool        empty_array = true;
     const char *ptr;
     ArrayParseState parse_state = ARRAY_NO_LEVEL;
 
     for (i = 0; i < MAXDIM; ++i)
     {
         temp[i] = dim[i] = nelems_last[i] = 0;
         nelems[i] = 1;
     }
 
     ptr = str;
     while (!eoArray)
     {
         bool        itemdone = false;
 
         while (!itemdone)
         {
             if (parse_state == ARRAY_ELEM_STARTED ||
                 parse_state == ARRAY_QUOTED_ELEM_STARTED)
                 empty_array = false;
 
             switch (*ptr)
             {
                 case '\0':
                     /* Signal a premature end of the string */
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                              errmsg("malformed array literal: \"%s\"", str),
                              errdetail("Unexpected end of input.")));
                     break;
                 case '\\':
 
                     /*
                      * An escape must be after a level start, after an element
                      * start, or after an element delimiter. In any case we
                      * now must be past an element start.
                      */
                     if (parse_state != ARRAY_LEVEL_STARTED &&
                         parse_state != ARRAY_ELEM_STARTED &&
                         parse_state != ARRAY_QUOTED_ELEM_STARTED &&
                         parse_state != ARRAY_ELEM_DELIMITED)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                               errmsg("malformed array literal: \"%s\"", str),
                                  errdetail("Unexpected \"%c\" character.",
                                            '\\')));
                     if (parse_state != ARRAY_QUOTED_ELEM_STARTED)
                         parse_state = ARRAY_ELEM_STARTED;
                     /* skip the escaped character */
                     if (*(ptr + 1))
                         ptr++;
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                               errmsg("malformed array literal: \"%s\"", str),
                                  errdetail("Unexpected end of input.")));
                     break;
                 case '\"':
 
                     /*
                      * A quote must be after a level start, after a quoted
                      * element start, or after an element delimiter. In any
                      * case we now must be past an element start.
                      */
                     if (parse_state != ARRAY_LEVEL_STARTED &&
                         parse_state != ARRAY_QUOTED_ELEM_STARTED &&
                         parse_state != ARRAY_ELEM_DELIMITED)
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                               errmsg("malformed array literal: \"%s\"", str),
                                  errdetail("Unexpected array element.")));
                     in_quotes = !in_quotes;
                     if (in_quotes)
                         parse_state = ARRAY_QUOTED_ELEM_STARTED;
                     else
                         parse_state = ARRAY_QUOTED_ELEM_COMPLETED;
                     break;
                 case '{':
                     if (!in_quotes)
                     {
                         /*
                          * A left brace can occur if no nesting has occurred
                          * yet, after a level start, or after a level
                          * delimiter.
                          */
                         if (parse_state != ARRAY_NO_LEVEL &&
                             parse_state != ARRAY_LEVEL_STARTED &&
                             parse_state != ARRAY_LEVEL_DELIMITED)
                             ereport(ERROR,
                                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                               errmsg("malformed array literal: \"%s\"", str),
                                 errdetail("Unexpected \"%c\" character.",
                                           '{')));
                         parse_state = ARRAY_LEVEL_STARTED;
                         if (nest_level >= MAXDIM)
                             ereport(ERROR,
                                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                                      errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
                                             nest_level + 1, MAXDIM)));
                         temp[nest_level] = 0;
                         nest_level++;
                         if (ndim < nest_level)
                             ndim = nest_level;
                     }
                     break;
                 case '}':
                     if (!in_quotes)
                     {
                         /*
                          * A right brace can occur after an element start, an
                          * element completion, a quoted element completion, or
                          * a level completion.
                          */
                         if (parse_state != ARRAY_ELEM_STARTED &&
                             parse_state != ARRAY_ELEM_COMPLETED &&
                             parse_state != ARRAY_QUOTED_ELEM_COMPLETED &&
                             parse_state != ARRAY_LEVEL_COMPLETED &&
                             !(nest_level == 1 && parse_state == ARRAY_LEVEL_STARTED))
                             ereport(ERROR,
                                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                               errmsg("malformed array literal: \"%s\"", str),
                                 errdetail("Unexpected \"%c\" character.",
                                           '}')));
                         parse_state = ARRAY_LEVEL_COMPLETED;
                         if (nest_level == 0)
                             ereport(ERROR,
                                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                               errmsg("malformed array literal: \"%s\"", str),
                              errdetail("Unmatched \"%c\" character.", '}')));
                         nest_level--;
 
                         if (nelems_last[nest_level] != 0 &&
                             nelems[nest_level] != nelems_last[nest_level])
                             ereport(ERROR,
                                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                               errmsg("malformed array literal: \"%s\"", str),
                                 errdetail("Multidimensional arrays must have "
                                           "sub-arrays with matching "
                                           "dimensions.")));
                         nelems_last[nest_level] = nelems[nest_level];
                         nelems[nest_level] = 1;
                         if (nest_level == 0)
                             eoArray = itemdone = true;
                         else
                         {
                             /*
                              * We don't set itemdone here; see comments in
                              * ReadArrayStr
                              */
                             temp[nest_level - 1]++;
                         }
                     }
                     break;
                 default:
                     if (!in_quotes)
                     {
                         if (*ptr == typdelim)
                         {
                             /*
                              * Delimiters can occur after an element start, an
                              * element completion, a quoted element
                              * completion, or a level completion.
                              */
                             if (parse_state != ARRAY_ELEM_STARTED &&
                                 parse_state != ARRAY_ELEM_COMPLETED &&
                                 parse_state != ARRAY_QUOTED_ELEM_COMPLETED &&
                                 parse_state != ARRAY_LEVEL_COMPLETED)
                                 ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                  errmsg("malformed array literal: \"%s\"", str),
                                  errdetail("Unexpected \"%c\" character.",
                                            typdelim)));
                             if (parse_state == ARRAY_LEVEL_COMPLETED)
                                 parse_state = ARRAY_LEVEL_DELIMITED;
                             else
                                 parse_state = ARRAY_ELEM_DELIMITED;
                             itemdone = true;
                             nelems[nest_level - 1]++;
                         }
                         else if (!array_isspace(*ptr))
                         {
                             /*
                              * Other non-space characters must be after a
                              * level start, after an element start, or after
                              * an element delimiter. In any case we now must
                              * be past an element start.
                              */
                             if (parse_state != ARRAY_LEVEL_STARTED &&
                                 parse_state != ARRAY_ELEM_STARTED &&
                                 parse_state != ARRAY_ELEM_DELIMITED)
                                 ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                  errmsg("malformed array literal: \"%s\"", str),
                                  errdetail("Unexpected array element.")));
                             parse_state = ARRAY_ELEM_STARTED;
                         }
                     }
                     break;
             }
             if (!itemdone)
                 ptr++;
         }
         temp[ndim - 1]++;
         ptr++;
     }
 
     /* only whitespace is allowed after the closing brace */
     while (*ptr)
     {
         if (!array_isspace(*ptr++))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                      errmsg("malformed array literal: \"%s\"", str),
                      errdetail("Junk after closing right brace.")));
     }
 
     /* special case for an empty array */
     if (empty_array)
         return 0;
 
     for (i = 0; i < ndim; ++i)
         dim[i] = temp[i];
 
     return ndim;
 }

Datum arrayoverlap ( PG_FUNCTION_ARGS )

Definition at line 4153 of file arrayfuncs.c.

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

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

Datum btarraycmp ( PG_FUNCTION_ARGS )

Definition at line 3719 of file arrayfuncs.c.

References array_cmp(), and PG_RETURN_INT32.

 {
     PG_RETURN_INT32(array_cmp(fcinfo));
 }

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

Definition at line 3277 of file arrayfuncs.c.

References construct_md_array(), and NULL.

Referenced by AlterPolicy(), build_regtype_array(), CreateConstraintEntry(), CreateFunction(), CreatePolicy(), current_schemas(), enum_range_internal(), extension_config_remove(), filter_list_to_array(), float4_accum(), float8_accum(), float8_regr_accum(), get_available_versions_for_extension(), gin_leafpage_items(), gin_page_opaque_info(), GUCArrayAdd(), GUCArrayDelete(), GUCArrayReset(), hstore_akeys(), interpret_function_parameter_list(), interval_accum(), interval_accum_inv(), pg_extension_config_dump(), pull_row_security_policies(), RelationBuildRowSecurity(), show_trgm(), strlist_to_textarray(), test_rls_hooks_permissive(), test_rls_hooks_restrictive(), ts_lexize(), typenameTypeMod(), and update_attstats().

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

ArrayType* construct_empty_array ( Oid elmtype )

Definition at line 3395 of file arrayfuncs.c.

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

Referenced by array_fill_internal(), array_get_slice(), array_in(), array_map(), array_recv(), array_replace_internal(), construct_empty_expanded_array(), construct_md_array(), exec_assign_value(), ExecEvalArray(), ExecEvalArrayRef(), hstore_akeys(), hstore_avals(), hstore_slice_to_array(), hstore_to_array_internal(), makeArrayResultArr(), percentile_cont_multi_final_common(), percentile_disc_multi_final(), pg_event_trigger_dropped_objects(), pg_identify_object_as_address(), text_to_array_internal(), and transformGenericOptions().

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

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

Definition at line 3412 of file arrayfuncs.c.

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

Referenced by fetch_array_arg_replace_nulls().

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

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

Definition at line 3311 of file arrayfuncs.c.

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

Referenced by array_iterate(), array_set_element(), array_set_slice(), build_regexp_matches_result(), construct_array(), create_singleton_array(), ExecEvalArray(), hstore_avals(), hstore_slice_to_array(), hstore_to_array_internal(), makeMdArrayResult(), percentile_cont_multi_final_common(), percentile_disc_multi_final(), plpgsql_exec_trigger(), and PLySequence_ToArray().

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

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

Definition at line 956 of file arrayfuncs.c.

References ARR_DATA_PTR, ARR_NULLBITMAP, ArrayCastAndSet(), DatumGetPointer, elog, ERROR, i, and pfree().

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

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

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

static

Definition at line 5677 of file arrayfuncs.c.

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

Referenced by array_fill_internal().

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

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

Definition at line 3446 of file arrayfuncs.c.

References ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), Assert, att_addlength_pointer, att_align_nominal, ereport, errcode(), errmsg(), ERROR, fetch_att, i, NULL, palloc(), and palloc0().

Referenced by _bt_preprocess_array_keys(), array_contain_compare(), array_set_slice(), array_to_json_internal(), array_to_jsonb_internal(), arrayconst_startup_fn(), ArrayGetIntegerTypmods(), binary_upgrade_create_empty_extension(), build_function_result_tupdesc_d(), compute_array_stats(), DecodeTextArrayToCString(), decompile_column_index_array(), deconstruct_expanded_array(), ExecIndexEvalArrayKeys(), extension_config_remove(), generateClonedIndexStmt(), get_attstatsslot(), get_func_arg_info(), get_func_input_arg_names(), get_func_result_name(), get_jsonb_path_all(), get_path_all(), ghstore_consistent(), gin_extract_hstore_query(), gin_extract_jsonb_query(), ginarrayextract(), gincost_scalararrayopexpr(), ginqueryarrayextract(), hstore_from_array(), hstore_from_arrays(), hstore_slice_to_array(), hstoreArrayToPairs(), interval_accum(), interval_accum_inv(), interval_avg(), json_object(), json_object_two_arg(), jsonb_delete_path(), jsonb_exists_all(), jsonb_exists_any(), jsonb_object(), jsonb_object_two_arg(), jsonb_set(), map_sql_value_to_xml_value(), mcelem_array_selec(), oid_array_to_list(), parse_key_value_arrays(), parseRelOptions(), percentile_cont_multi_final_common(), percentile_disc_multi_final(), pg_get_constraintdef_worker(), pg_get_object_address(), pg_logical_slot_get_changes_guts(), plperl_ref_from_pg_array(), scalararraysel(), text_format(), textarray_to_strvaluelist(), TidListCreate(), transformRelOptions(), tsa_rewrite_accum(), and untransformRelOptions().

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

Datum generate_subscripts ( PG_FUNCTION_ARGS )

Definition at line 5526 of file arrayfuncs.c.

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

Referenced by generate_subscripts_nodir().

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

Datum generate_subscripts_nodir ( PG_FUNCTION_ARGS )

Definition at line 5590 of file arrayfuncs.c.

References generate_subscripts().

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

Datum hash_array ( PG_FUNCTION_ARGS )

Definition at line 3902 of file arrayfuncs.c.

References AARR_DIMS, AARR_ELEMTYPE, AARR_FREE_IF_COPY, AARR_NDIM, FunctionCallInfoData::arg, FunctionCallInfoData::argnull, array_iter_next(), array_iter_setup(), ArrayGetNItems(), DatumGetUInt32, ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCallInvoke, TypeCacheEntry::hash_proc_finfo, i, InitFunctionCallInfoData, InvalidOid, FunctionCallInfoData::isnull, lookup_type_cache(), NULL, OidIsValid, PG_GETARG_ANY_ARRAY, PG_RETURN_UINT32, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TYPECACHE_HASH_PROC_FINFO, and TypeCacheEntry::typlen.

 {
     AnyArrayType *array = PG_GETARG_ANY_ARRAY(0);
     int         ndims = AARR_NDIM(array);
     int        *dims = AARR_DIMS(array);
     Oid         element_type = AARR_ELEMTYPE(array);
     uint32      result = 1;
     int         nitems;
     TypeCacheEntry *typentry;
     int         typlen;
     bool        typbyval;
     char        typalign;
     int         i;
     array_iter  iter;
     FunctionCallInfoData locfcinfo;
 
     /*
      * We arrange to look up the hash function only once per series of calls,
      * assuming the element type doesn't change underneath us.  The typcache
      * is used so that we have no memory leakage when being used as an index
      * support function.
      */
     typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
     if (typentry == NULL ||
         typentry->type_id != element_type)
     {
         typentry = lookup_type_cache(element_type,
                                      TYPECACHE_HASH_PROC_FINFO);
         if (!OidIsValid(typentry->hash_proc_finfo.fn_oid))
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_FUNCTION),
                      errmsg("could not identify a hash 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 hash function to each array element.
      */
     InitFunctionCallInfoData(locfcinfo, &typentry->hash_proc_finfo, 1,
                              InvalidOid, NULL, NULL);
 
     /* Loop over source data */
     nitems = ArrayGetNItems(ndims, dims);
     array_iter_setup(&iter, array);
 
     for (i = 0; i < nitems; i++)
     {
         Datum       elt;
         bool        isnull;
         uint32      elthash;
 
         /* Get element, checking for NULL */
         elt = array_iter_next(&iter, &isnull, i, typlen, typbyval, typalign);
 
         if (isnull)
         {
             /* Treat nulls as having hashvalue 0 */
             elthash = 0;
         }
         else
         {
             /* Apply the hash function */
             locfcinfo.arg[0] = elt;
             locfcinfo.argnull[0] = false;
             locfcinfo.isnull = false;
             elthash = DatumGetUInt32(FunctionCallInvoke(&locfcinfo));
         }
 
         /*
          * Combine hash values of successive elements by multiplying the
          * current value by 31 and adding on the new element's hash value.
          *
          * The result is a sum in which each element's hash value is
          * multiplied by a different power of 31. This is modulo 2^32
          * arithmetic, and the powers of 31 modulo 2^32 form a cyclic group of
          * order 2^27. So for arrays of up to 2^27 elements, each element's
          * hash value is multiplied by a different (odd) number, resulting in
          * a good mixing of all the elements' hash values.
          */
         result = (result << 5) - result + elthash;
     }
 
     /* Avoid leaking memory when handed toasted input. */
     AARR_FREE_IF_COPY(array, 0);
 
     PG_RETURN_UINT32(result);
 }

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

Definition at line 4922 of file arrayfuncs.c.

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

Referenced by accumArrayResult(), array_agg_transfn(), array_positions(), initArrayResultAny(), plperl_array_to_datum(), and xpath().

 {
     ArrayBuildState *astate;
     MemoryContext arr_context = rcontext;
 
     /* Make a temporary context to hold all the junk */
     if (subcontext)
         arr_context = AllocSetContextCreate(rcontext,
                                             "accumArrayResult",
                                             ALLOCSET_DEFAULT_MINSIZE,
                                             ALLOCSET_DEFAULT_INITSIZE,
                                             ALLOCSET_DEFAULT_MAXSIZE);
 
     astate = (ArrayBuildState *)
         MemoryContextAlloc(arr_context, sizeof(ArrayBuildState));
     astate->mcontext = arr_context;
     astate->private_cxt = subcontext;
     astate->alen = (subcontext ? 64 : 8);       /* arbitrary starting array
                                                  * size */
     astate->dvalues = (Datum *)
         MemoryContextAlloc(arr_context, astate->alen * sizeof(Datum));
     astate->dnulls = (bool *)
         MemoryContextAlloc(arr_context, astate->alen * sizeof(bool));
     astate->nelems = 0;
     astate->element_type = element_type;
     get_typlenbyvalalign(element_type,
                          &astate->typlen,
                          &astate->typbyval,
                          &astate->typalign);
 
     return astate;
 }

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

Definition at line 5393 of file arrayfuncs.c.

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

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

 {
     ArrayBuildStateAny *astate;
     Oid         element_type = get_element_type(input_type);
 
     if (OidIsValid(element_type))
     {
         /* Array case */
         ArrayBuildStateArr *arraystate;
 
         arraystate = initArrayResultArr(input_type, InvalidOid, rcontext, subcontext);
         astate = (ArrayBuildStateAny *)
             MemoryContextAlloc(arraystate->mcontext,
                                sizeof(ArrayBuildStateAny));
         astate->scalarstate = NULL;
         astate->arraystate = arraystate;
     }
     else
     {
         /* Scalar case */
         ArrayBuildState *scalarstate;
 
         /* Let's just check that we have a type that can be put into arrays */
         Assert(OidIsValid(get_array_type(input_type)));
 
         scalarstate = initArrayResult(input_type, rcontext, subcontext);
         astate = (ArrayBuildStateAny *)
             MemoryContextAlloc(scalarstate->mcontext,
                                sizeof(ArrayBuildStateAny));
         astate->scalarstate = scalarstate;
         astate->arraystate = NULL;
     }
 
     return astate;
 }

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

Definition at line 5112 of file arrayfuncs.c.

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

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

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

Datum makeArrayResult	(	ArrayBuildState *	astate,
		MemoryContext	rcontext
	)

Definition at line 5028 of file arrayfuncs.c.

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

Referenced by array_positions(), dblink_get_connections(), get_altertable_subcmdtypes(), optionListToArray(), regexp_split_to_array(), text_to_array_internal(), transformRelOptions(), and xpath().

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

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

Definition at line 5466 of file arrayfuncs.c.

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

Referenced by ExecScanSubPlan(), and ExecSetParamPlan().

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

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

Definition at line 5318 of file arrayfuncs.c.

Referenced by array_agg_array_finalfn(), and makeArrayResultAny().

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

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

Definition at line 5060 of file arrayfuncs.c.

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

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

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

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

static

Definition at line 1429 of file arrayfuncs.c.

References AllocSizeIsValid, att_addlength_datum, att_align_nominal, StringInfoData::cursor, StringInfoData::data, ereport, errcode(), errmsg(), ERROR, i, StringInfoData::len, MaxAllocSize, StringInfoData::maxlen, NULL, PG_DETOAST_DATUM, PointerGetDatum, pq_getmsgint(), and ReceiveFunctionCall().

Referenced by array_recv().

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

static void 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
	)

static

Definition at line 716 of file arrayfuncs.c.

References AllocSizeIsValid, array_isspace(), Array_nulls, ArrayGetOffset0(), Assert, att_addlength_datum, att_align_nominal, ereport, errcode(), errmsg(), ERROR, i, InputFunctionCall(), MaxAllocSize, MAXDIM, mda_get_prod(), MemSet, NULL, PG_DETOAST_DATUM, pg_strcasecmp(), and PointerGetDatum.

Referenced by array_in().

 {
     int         i,
                 nest_level = 0;
     char       *srcptr;
     bool        in_quotes = false;
     bool        eoArray = false;
     bool        hasnull;
     int32       totbytes;
     int         indx[MAXDIM],
                 prod[MAXDIM];
 
     mda_get_prod(ndim, dim, prod);
     MemSet(indx, 0, sizeof(indx));
 
     /* Initialize is-null markers to true */
     memset(nulls, true, nitems * sizeof(bool));
 
     /*
      * We have to remove " and \ characters to create a clean item value to
      * pass to the datatype input routine.  We overwrite each item value
      * in-place within arrayStr to do this.  srcptr is the current scan point,
      * and dstptr is where we are copying to.
      *
      * We also want to suppress leading and trailing unquoted whitespace. We
      * use the leadingspace flag to suppress leading space.  Trailing space is
      * tracked by using dstendptr to point to the last significant output
      * character.
      *
      * The error checking in this routine is mostly pro-forma, since we expect
      * that ArrayCount() already validated the string.  So we don't bother
      * with errdetail messages.
      */
     srcptr = arrayStr;
     while (!eoArray)
     {
         bool        itemdone = false;
         bool        leadingspace = true;
         bool        hasquoting = false;
         char       *itemstart;
         char       *dstptr;
         char       *dstendptr;
 
         i = -1;
         itemstart = dstptr = dstendptr = srcptr;
 
         while (!itemdone)
         {
             switch (*srcptr)
             {
                 case '\0':
                     /* Signal a premature end of the string */
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                              errmsg("malformed array literal: \"%s\"",
                                     origStr)));
                     break;
                 case '\\':
                     /* Skip backslash, copy next character as-is. */
                     srcptr++;
                     if (*srcptr == '\0')
                         ereport(ERROR,
                                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                  errmsg("malformed array literal: \"%s\"",
                                         origStr)));
                     *dstptr++ = *srcptr++;
                     /* Treat the escaped character as non-whitespace */
                     leadingspace = false;
                     dstendptr = dstptr;
                     hasquoting = true;  /* can't be a NULL marker */
                     break;
                 case '\"':
                     in_quotes = !in_quotes;
                     if (in_quotes)
                         leadingspace = false;
                     else
                     {
                         /*
                          * Advance dstendptr when we exit in_quotes; this
                          * saves having to do it in all the other in_quotes
                          * cases.
                          */
                         dstendptr = dstptr;
                     }
                     hasquoting = true;  /* can't be a NULL marker */
                     srcptr++;
                     break;
                 case '{':
                     if (!in_quotes)
                     {
                         if (nest_level >= ndim)
                             ereport(ERROR,
                                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                 errmsg("malformed array literal: \"%s\"",
                                        origStr)));
                         nest_level++;
                         indx[nest_level - 1] = 0;
                         srcptr++;
                     }
                     else
                         *dstptr++ = *srcptr++;
                     break;
                 case '}':
                     if (!in_quotes)
                     {
                         if (nest_level == 0)
                             ereport(ERROR,
                                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                 errmsg("malformed array literal: \"%s\"",
                                        origStr)));
                         if (i == -1)
                             i = ArrayGetOffset0(ndim, indx, prod);
                         indx[nest_level - 1] = 0;
                         nest_level--;
                         if (nest_level == 0)
                             eoArray = itemdone = true;
                         else
                             indx[nest_level - 1]++;
                         srcptr++;
                     }
                     else
                         *dstptr++ = *srcptr++;
                     break;
                 default:
                     if (in_quotes)
                         *dstptr++ = *srcptr++;
                     else if (*srcptr == typdelim)
                     {
                         if (i == -1)
                             i = ArrayGetOffset0(ndim, indx, prod);
                         itemdone = true;
                         indx[ndim - 1]++;
                         srcptr++;
                     }
                     else if (array_isspace(*srcptr))
                     {
                         /*
                          * If leading space, drop it immediately.  Else, copy
                          * but don't advance dstendptr.
                          */
                         if (leadingspace)
                             srcptr++;
                         else
                             *dstptr++ = *srcptr++;
                     }
                     else
                     {
                         *dstptr++ = *srcptr++;
                         leadingspace = false;
                         dstendptr = dstptr;
                     }
                     break;
             }
         }
 
         Assert(dstptr < srcptr);
         *dstendptr = '\0';
 
         if (i < 0 || i >= nitems)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                      errmsg("malformed array literal: \"%s\"",
                             origStr)));
 
         if (Array_nulls && !hasquoting &&
             pg_strcasecmp(itemstart, "NULL") == 0)
         {
             /* it's a NULL item */
             values[i] = InputFunctionCall(inputproc, NULL,
                                           typioparam, typmod);
             nulls[i] = true;
         }
         else
         {
             values[i] = InputFunctionCall(inputproc, itemstart,
                                           typioparam, typmod);
             nulls[i] = false;
         }
     }
 
     /*
      * Check for nulls, compute total data space needed
      */
     hasnull = false;
     totbytes = 0;
     for (i = 0; i < nitems; i++)
     {
         if (nulls[i])
             hasnull = true;
         else
         {
             /* let's just make sure data is not toasted */
             if (typlen == -1)
                 values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
             totbytes = att_addlength_datum(totbytes, typlen, values[i]);
             totbytes = att_align_nominal(totbytes, typalign);
             /* check for overflow of total request */
             if (!AllocSizeIsValid(totbytes))
                 ereport(ERROR,
                         (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                          errmsg("array size exceeds the maximum allowed (%d)",
                                 (int) MaxAllocSize)));
         }
     }
     *hasnulls = hasnull;
     *nbytes = totbytes;
 }

Datum width_bucket_array ( PG_FUNCTION_ARGS )

Definition at line 6276 of file arrayfuncs.c.

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

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

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

static

Definition at line 6383 of file arrayfuncs.c.

References FunctionCallInfoData::arg, FunctionCallInfoData::argnull, ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, ArrayGetNItems(), TypeCacheEntry::cmp_proc_finfo, DatumGetInt32, fetch_att, FunctionCallInvoke, InitFunctionCallInfoData, FunctionCallInfoData::isnull, NULL, TypeCacheEntry::typbyval, and TypeCacheEntry::typlen.

Referenced by width_bucket_array().

 {
     char       *thresholds_data;
     int         typlen = typentry->typlen;
     bool        typbyval = typentry->typbyval;
     FunctionCallInfoData locfcinfo;
     int         left;
     int         right;
 
     /*
      * Since we know the array contains no NULLs, we can just index it
      * directly.
      */
     thresholds_data = (char *) ARR_DATA_PTR(thresholds);
 
     InitFunctionCallInfoData(locfcinfo, &typentry->cmp_proc_finfo, 2,
                              collation, NULL, NULL);
 
     /* Find the bucket */
     left = 0;
     right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
     while (left < right)
     {
         int         mid = (left + right) / 2;
         char       *ptr;
         int32       cmpresult;
 
         ptr = thresholds_data + mid * typlen;
 
         locfcinfo.arg[0] = operand;
         locfcinfo.arg[1] = fetch_att(ptr, typbyval, typlen);
         locfcinfo.argnull[0] = false;
         locfcinfo.argnull[1] = false;
         locfcinfo.isnull = false;
 
         cmpresult = DatumGetInt32(FunctionCallInvoke(&locfcinfo));
 
         if (cmpresult < 0)
             right = mid;
         else
             left = mid + 1;
     }
 
     return left;
 }

static int width_bucket_array_float8	(	Datum	operand,
		ArrayType *	thresholds
	)

static

Definition at line 6339 of file arrayfuncs.c.

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

Referenced by width_bucket_array().

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

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

static

Definition at line 6436 of file arrayfuncs.c.

References FunctionCallInfoData::arg, FunctionCallInfoData::argnull, ARR_DATA_PTR, ARR_DIMS, ARR_NDIM, ArrayGetNItems(), att_addlength_pointer, att_align_nominal, TypeCacheEntry::cmp_proc_finfo, DatumGetInt32, fetch_att, FunctionCallInvoke, i, InitFunctionCallInfoData, FunctionCallInfoData::isnull, NULL, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, and TypeCacheEntry::typlen.

Referenced by width_bucket_array().

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

Variable Documentation

bool Array_nulls = true

Definition at line 39 of file arrayfuncs.c.

Referenced by ReadArrayStr().

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation