Quelle  arrayfuncs.c

/*-------------------------------------------------------------------------
 *
 * arrayfuncs.c
 *   Support functions for arrays.
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/utils/adt/arrayfuncs.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include <ctype.h>
#include <math.h>

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


/*
 * GUC parameter
 */
bool  Array_nulls = true;

/*
 * Local definitions
 */
#define ASSGN  "="

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

/* ReadArrayToken return type */
typedef enum
{
 ATOK_LEVEL_START,
 ATOK_LEVEL_END,
 ATOK_DELIM,
 ATOK_ELEM,
 ATOK_ELEM_NULL,
 ATOK_ERROR,
} ArrayToken;

/* Working state for array_iterate() */
typedef struct ArrayIteratorData
{
 /* basic info about the array, set up during array_create_iterator() */
 ArrayType  *arr;   /* array we're iterating through */
 bits8    *nullbitmap;  /* its null bitmap, if any */
 int   nitems;   /* total number of elements in array */
 int16  typlen;   /* element type's length */
 bool  typbyval;  /* element type's byval property */
 char  typalign;  /* element type's align property */

 /* information about the requested slice size */
 int   slice_ndim;  /* slice dimension, or 0 if not slicing */
 int   slice_len;  /* number of elements per slice */
 int     *slice_dims;  /* slice dims array */
 int     *slice_lbound; /* slice lbound array */
 Datum    *slice_values; /* workspace of length slice_len */
 bool    *slice_nulls; /* workspace of length slice_len */

 /* current position information, updated on each iteration */
 char    *data_ptr;  /* our current position in the array */
 int   current_item; /* the item # we're at in the array */
}   ArrayIteratorData;

static bool ReadArrayDimensions(char **srcptr, int *ndim_p,
        int *dim, int *lBound,
        const char *origStr, Node *escontext);
static bool ReadDimensionInt(char **srcptr, int *result,
        const char *origStr, Node *escontext);
static bool ReadArrayStr(char **srcptr,
       FmgrInfo *inputproc, Oid typioparam, int32 typmod,
       char typdelim,
       int typlen, bool typbyval, char typalign,
       int *ndim_p, int *dim,
       int *nitems_p,
       Datum **values_p, bool **nulls_p,
       const char *origStr, Node *escontext);
static ArrayToken ReadArrayToken(char **srcptr, StringInfo elembuf, char typdelim,
         const char *origStr, Node *escontext);
static void ReadArrayBinary(StringInfo buf, int nitems,
       FmgrInfo *receiveproc, Oid typioparam, int32 typmod,
       int typlen, bool typbyval, char typalign,
       Datum *values, bool *nulls,
       bool *hasnulls, int32 *nbytes);
static Datum array_get_element_expanded(Datum arraydatum,
          int nSubscripts, int *indx,
          int arraytyplen,
          int elmlen, bool elmbyval, char elmalign,
          bool *isNull);
static Datum array_set_element_expanded(Datum arraydatum,
          int nSubscripts, int *indx,
          Datum dataValue, bool isNull,
          int arraytyplen,
          int elmlen, bool elmbyval, char elmalign);
static bool array_get_isnull(const bits8 *nullbitmap, int offset);
static void array_set_isnull(bits8 *nullbitmap, int offset, bool isNull);
static Datum ArrayCast(char *value, bool byval, int len);
static int ArrayCastAndSet(Datum src,
       int typlen, bool typbyval, char typalign,
       char *dest);
static char *array_seek(char *ptr, int offset, bits8 *nullbitmap, int nitems,
      int typlen, bool typbyval, char typalign);
static int array_nelems_size(char *ptr, int offset, bits8 *nullbitmap,
         int nitems, int typlen, bool typbyval, char typalign);
static int array_copy(char *destptr, int nitems,
        char *srcptr, int offset, bits8 *nullbitmap,
        int typlen, bool typbyval, char typalign);
static int array_slice_size(char *arraydataptr, bits8 *arraynullsptr,
        int ndim, int *dim, int *lb,
        int *st, int *endp,
        int typlen, bool typbyval, char typalign);
static void array_extract_slice(ArrayType *newarray,
        int ndim, int *dim, int *lb,
        char *arraydataptr, bits8 *arraynullsptr,
        int *st, int *endp,
        int typlen, bool typbyval, char typalign);
static void array_insert_slice(ArrayType *destArray, ArrayType *origArray,
          ArrayType *srcArray,
          int ndim, int *dim, int *lb,
          int *st, int *endp,
          int typlen, bool typbyval, char typalign);
static int array_cmp(FunctionCallInfo fcinfo);
static ArrayType *create_array_envelope(int ndims, int *dimv, int *lbsv, int nbytes,
          Oid elmtype, int dataoffset);
static ArrayType *array_fill_internal(ArrayType *dims, ArrayType *lbs,
           Datum value, bool isnull, Oid elmtype,
           FunctionCallInfo fcinfo);
static ArrayType *array_replace_internal(ArrayType *array,
           Datum search, bool search_isnull,
           Datum replace, bool replace_isnull,
           bool remove, Oid collation,
           FunctionCallInfo fcinfo);
static int width_bucket_array_float8(Datum operand, ArrayType *thresholds);
static int width_bucket_array_fixed(Datum operand,
          ArrayType *thresholds,
          Oid collation,
          TypeCacheEntry *typentry);
static int width_bucket_array_variable(Datum operand,
          ArrayType *thresholds,
          Oid collation,
          TypeCacheEntry *typentry);


/*
 * array_in :
 *    converts an array from the external format in "string" to
 *    its internal format.
 *
 * return value :
 *    the internal representation of the input array
 */
Datum
array_in(PG_FUNCTION_ARGS)
{
 char    *string = PG_GETARG_CSTRING(0); /* external form */
 Oid   element_type = PG_GETARG_OID(1); /* type of an array
 * element */
 int32  typmod = PG_GETARG_INT32(2); /* typmod for array elements */
 Node    *escontext = fcinfo->context;
 int   typlen;
 bool  typbyval;
 char  typalign;
 char  typdelim;
 Oid   typioparam;
 char    *p;
 int   nitems;
 Datum    *values;
 bool    *nulls;
 bool  hasnulls;
 int32  nbytes;
 int32  dataoffset;
 ArrayType  *retval;
 int   ndim,
    dim[MAXDIM],
    lBound[MAXDIM];
 ArrayMetaState *my_extra;

 /*
  * We arrange to look up info about element type, including its input
  * conversion proc, only once per series of calls, assuming the element
  * type doesn't change underneath us.
 */
 my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
 if (my_extra == NULL)
 {
  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
               sizeof(ArrayMetaState));
  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
  my_extra->element_type = ~element_type;
 }

 if (my_extra->element_type != element_type)
 {
  /*
   * Get info about element type, including its input conversion proc
 */
  get_type_io_data(element_type, IOFunc_input,
       &my_extra->typlen, &my_extra->typbyval,
       &my_extra->typalign, &my_extra->typdelim,
       &my_extra->typioparam, &my_extra->typiofunc);
  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
       fcinfo->flinfo->fn_mcxt);
  my_extra->element_type = element_type;
 }
 typlen = my_extra->typlen;
 typbyval = my_extra->typbyval;
 typalign = my_extra->typalign;
 typdelim = my_extra->typdelim;
 typioparam = my_extra->typioparam;

 /*
  * Initialize dim[] and lBound[] for ReadArrayStr, in case there is no
  * explicit dimension info.  (If there is, ReadArrayDimensions will
  * overwrite this.)
 */
 for (int i = 0; i < MAXDIM; i++)
 {
  dim[i] = -1;   /* indicates "not yet known" */
  lBound[i] = 1;   /* default lower bound */
 }

 /*
  * Start processing the input string.
  *
  * If the input string starts with dimension info, read and use that.
  * Otherwise, we'll determine the dimensions during ReadArrayStr.
 */
 p = string;
 if (!ReadArrayDimensions(&p, &ndim, dim, lBound, string, escontext))
  return (Datum) 0;

 if (ndim == 0)
 {
  /* No array dimensions, so next character should be a left brace */
  if (*p != '{')
   ereturn(escontext, (Datum) 0,
     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      errmsg("malformed array literal: \"%s\"", string),
      errdetail("Array value must start with \"{\" or dimension information.")));
 }
 else
 {
  /* If array dimensions are given, expect '=' operator */
  if (strncmp(p, ASSGN, strlen(ASSGN)) != 0)
   ereturn(escontext, (Datum) 0,
     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      errmsg("malformed array literal: \"%s\"", string),
      errdetail("Missing \"%s\" after array dimensions.",
          ASSGN)));
  p += strlen(ASSGN);
  /* Allow whitespace after it */
  while (scanner_isspace(*p))
   p++;

  if (*p != '{')
   ereturn(escontext, (Datum) 0,
     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      errmsg("malformed array literal: \"%s\"", string),
      errdetail("Array contents must start with \"{\".")));
 }

 /* Parse the value part, in the curly braces: { ... } */
 if (!ReadArrayStr(&p,
       &my_extra->proc, typioparam, typmod,
       typdelim,
       typlen, typbyval, typalign,
       &ndim,
       dim,
       &nitems,
       &values, &nulls,
       string,
       escontext))
  return (Datum) 0;

 /* only whitespace is allowed after the closing brace */
 while (*p)
 {
  if (!scanner_isspace(*p++))
   ereturn(escontext, (Datum) 0,
     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      errmsg("malformed array literal: \"%s\"", string),
      errdetail("Junk after closing right brace.")));
 }

 /* Empty array? */
 if (nitems == 0)
  PG_RETURN_ARRAYTYPE_P(construct_empty_array(element_type));

 /*
  * Check for nulls, compute total data space needed
 */
 hasnulls = false;
 nbytes = 0;
 for (int i = 0; i < nitems; i++)
 {
  if (nulls[i])
   hasnulls = true;
  else
  {
   /* let's just make sure data is not toasted */
   if (typlen == -1)
    values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
   nbytes = att_addlength_datum(nbytes, typlen, values[i]);
   nbytes = att_align_nominal(nbytes, typalign);
   /* check for overflow of total request */
   if (!AllocSizeIsValid(nbytes))
    ereturn(escontext, (Datum) 0,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxAllocSize)));
  }
 }
 if (hasnulls)
 {
  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
  nbytes += dataoffset;
 }
 else
 {
  dataoffset = 0;   /* marker for no null bitmap */
  nbytes += ARR_OVERHEAD_NONULLS(ndim);
 }

 /*
  * Construct the final array datum
 */
 retval = (ArrayType *) palloc0(nbytes);
 SET_VARSIZE(retval, nbytes);
 retval->ndim = ndim;
 retval->dataoffset = dataoffset;

 /*
  * This comes from the array's pg_type.typelem (which points to the base
  * data type's pg_type.oid) and stores system oids in user tables. This
  * oid must be preserved by binary upgrades.
 */
 retval->elemtype = element_type;
 memcpy(ARR_DIMS(retval), dim, ndim * sizeof(int));
 memcpy(ARR_LBOUND(retval), lBound, ndim * sizeof(int));

 CopyArrayEls(retval,
     values, nulls, nitems,
     typlen, typbyval, typalign,
     true);

 pfree(values);
 pfree(nulls);

 PG_RETURN_ARRAYTYPE_P(retval);
}

/*
 * ReadArrayDimensions
 *  parses the array dimensions part of the input and converts the values
 *  to internal format.
 *
 * On entry, *srcptr points to the string to parse. It is advanced to point
 * after whitespace (if any) and dimension info (if any).
 *
 * *ndim_p, dim[], and lBound[] are output variables. They are filled with the
 * number of dimensions (<= MAXDIM), the lengths of each dimension, and the
 * lower subscript bounds, respectively.  If no dimension info appears,
 * *ndim_p will be set to zero, and dim[] and lBound[] are unchanged.
 *
 * 'origStr' is the original input string, used only in error messages.
 * If *escontext points to an ErrorSaveContext, details of any error are
 * reported there.
 *
 * Result:
 * true for success, false for failure (if escontext is provided).
 *
 * Note that dim[] and lBound[] are allocated by the caller, and must have
 * MAXDIM elements.
 */
static bool
ReadArrayDimensions(char **srcptr, int *ndim_p, int *dim, int *lBound,
     const char *origStr, Node *escontext)
{
 char    *p = *srcptr;
 int   ndim;

 /*
  * Dimension info takes the form of one or more [n] or [m:n] items.  This
  * loop iterates once per dimension item.
 */
 ndim = 0;
 for (;;)
 {
  char    *q;
  int   ub;
  int   i;

  /*
   * Note: we currently allow whitespace between, but not within,
   * dimension items.
 */
  while (scanner_isspace(*p))
   p++;
  if (*p != '[')
   break;    /* no more dimension items */
  p++;
  if (ndim >= MAXDIM)
   ereturn(escontext, false,
     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
      errmsg("number of array dimensions exceeds the maximum allowed (%d)",
       MAXDIM)));

  q = p;
  if (!ReadDimensionInt(&p, &i, origStr, escontext))
   return false;
  if (p == q)    /* no digits? */
   ereturn(escontext, false,
     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      errmsg("malformed array literal: \"%s\"", origStr),
      errdetail("\"[\" must introduce explicitly-specified array dimensions.")));

  if (*p == ':')
  {
   /* [m:n] format */
   lBound[ndim] = i;
   p++;
   q = p;
   if (!ReadDimensionInt(&p, &ub, origStr, escontext))
    return false;
   if (p == q)   /* no digits? */
    ereturn(escontext, false,
      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
       errmsg("malformed array literal: \"%s\"", origStr),
       errdetail("Missing array dimension value.")));
  }
  else
  {
   /* [n] format */
   lBound[ndim] = 1;
   ub = i;
  }
  if (*p != ']')
   ereturn(escontext, false,
     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      errmsg("malformed array literal: \"%s\"", origStr),
      errdetail("Missing \"%s\" after array dimensions.",
          "]")));
  p++;

  /*
   * Note: we could accept ub = lb-1 to represent a zero-length
   * dimension.  However, that would result in an empty array, for which
   * we don't keep any dimension data, so that e.g. [1:0] and [101:100]
   * would be equivalent.  Given the lack of field demand, there seems
   * little point in allowing such cases.
 */
  if (ub < lBound[ndim])
   ereturn(escontext, false,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("upper bound cannot be less than lower bound")));

  /* Upper bound of INT_MAX must be disallowed, cf ArrayCheckBounds() */
  if (ub == INT_MAX)
   ereturn(escontext, false,
     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
      errmsg("array upper bound is too large: %d", ub)));

  /* Compute "ub - lBound[ndim] + 1", detecting overflow */
  if (pg_sub_s32_overflow(ub, lBound[ndim], &ub) ||
   pg_add_s32_overflow(ub, 1, &ub))
   ereturn(escontext, false,
     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
      errmsg("array size exceeds the maximum allowed (%d)",
       (int) MaxArraySize)));

  dim[ndim] = ub;
  ndim++;
 }

 *srcptr = p;
 *ndim_p = ndim;
 return true;
}

/*
 * ReadDimensionInt
 *  parse an integer, for the array dimensions
 *
 * On entry, *srcptr points to the string to parse. It is advanced past the
 * digits of the integer. If there are no digits, returns true and leaves
 * *srcptr unchanged.
 *
 * Result:
 * true for success, false for failure (if escontext is provided).
 *  On success, the parsed integer is returned in *result.
 */
static bool
ReadDimensionInt(char **srcptr, int *result,
     const char *origStr, Node *escontext)
{
 char    *p = *srcptr;
 long  l;

 /* don't accept leading whitespace */
 if (!isdigit((unsigned char) *p) && *p != '-' && *p != '+')
 {
  *result = 0;
  return true;
 }

 errno = 0;
 l = strtol(p, srcptr, 10);

 if (errno == ERANGE || l > PG_INT32_MAX || l < PG_INT32_MIN)
  ereturn(escontext, false,
    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     errmsg("array bound is out of integer range")));

 *result = (int) l;
 return true;
}

/*
 * ReadArrayStr :
 *  parses the array string pointed to by *srcptr and converts the values
 *  to internal format.  Determines the array dimensions as it goes.
 *
 * On entry, *srcptr points to the string to parse (it must point to a '{').
 * On successful return, it is advanced to point past the closing '}'.
 *
 * If dimensions were specified explicitly, they are passed in *ndim_p and
 * dim[].  This function will check that the array values match the specified
 * dimensions.  If dimensions were not given, caller must pass *ndim_p == 0
 * and initialize all elements of dim[] to -1.  Then this function will
 * deduce the dimensions from the structure of the input and store them in
 * *ndim_p and the dim[] array.
 *
 * Element type information:
 * inputproc: type-specific input procedure for element datatype.
 * typioparam, typmod: auxiliary values to pass to inputproc.
 * typdelim: the value delimiter (type-specific).
 * typlen, typbyval, typalign: storage parameters of element datatype.
 *
 * Outputs:
 *  *ndim_p, dim: dimensions deduced from the input structure.
 *  *nitems_p: total number of elements.
 * *values_p[]: palloc'd array, filled with converted data values.
 * *nulls_p[]: palloc'd array, filled with is-null markers.
 *
 * 'origStr' is the original input string, used only in error messages.
 * If *escontext points to an ErrorSaveContext, details of any error are
 * reported there.
 *
 * Result:
 * true for success, false for failure (if escontext is provided).
 */
static bool
ReadArrayStr(char **srcptr,
    FmgrInfo *inputproc,
    Oid typioparam,
    int32 typmod,
    char typdelim,
    int typlen,
    bool typbyval,
    char typalign,
    int *ndim_p,
    int *dim,
    int *nitems_p,
    Datum **values_p,
    bool **nulls_p,
    const char *origStr,
    Node *escontext)
{
 int   ndim = *ndim_p;
 bool  dimensions_specified = (ndim != 0);
 int   maxitems;
 Datum    *values;
 bool    *nulls;
 StringInfoData elembuf;
 int   nest_level;
 int   nitems;
 bool  ndim_frozen;
 bool  expect_delim;
 int   nelems[MAXDIM];

 /* Allocate some starting output workspace; we'll enlarge as needed */
 maxitems = 16;
 values = palloc_array(Datum, maxitems);
 nulls = palloc_array(bool, maxitems);

 /* Allocate workspace to hold (string representation of) one element */
 initStringInfo(&elembuf);

 /* Loop below assumes first token is ATOK_LEVEL_START */
 Assert(**srcptr == '{');

 /* Parse tokens until we reach the matching right brace */
 nest_level = 0;
 nitems = 0;
 ndim_frozen = dimensions_specified;
 expect_delim = false;
 do
 {
  ArrayToken tok;

  tok = ReadArrayToken(srcptr, &elembuf, typdelim, origStr, escontext);

  switch (tok)
  {
   case ATOK_LEVEL_START:
    /* Can't write left brace where delim is expected */
    if (expect_delim)
     ereturn(escontext, false,
       (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
        errmsg("malformed array literal: \"%s\"", origStr),
        errdetail("Unexpected \"%c\" character.", '{')));

    /* Initialize element counting in the new level */
    if (nest_level >= MAXDIM)
     ereturn(escontext, false,
       (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
        errmsg("number of array dimensions exceeds the maximum allowed (%d)",
         MAXDIM)));

    nelems[nest_level] = 0;
    nest_level++;
    if (nest_level > ndim)
    {
     /* Can't increase ndim once it's frozen */
     if (ndim_frozen)
      goto dimension_error;
     ndim = nest_level;
    }
    break;

   case ATOK_LEVEL_END:
    /* Can't get here with nest_level == 0 */
    Assert(nest_level > 0);

    /*
     * We allow a right brace to terminate an empty sub-array,
     * otherwise it must occur where we expect a delimiter.
 */
    if (nelems[nest_level - 1] > 0 && !expect_delim)
     ereturn(escontext, false,
       (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
        errmsg("malformed array literal: \"%s\"", origStr),
        errdetail("Unexpected \"%c\" character.",
            '}')));
    nest_level--;
    /* Nested sub-arrays count as elements of outer level */
    if (nest_level > 0)
     nelems[nest_level - 1]++;

    /*
     * Note: if we had dimensionality info, then dim[nest_level]
     * is initially non-negative, and we'll check each sub-array's
     * length against that.
 */
    if (dim[nest_level] < 0)
    {
     /* Save length of first sub-array of this level */
     dim[nest_level] = nelems[nest_level];
    }
    else if (nelems[nest_level] != dim[nest_level])
    {
     /* Subsequent sub-arrays must have same length */
     goto dimension_error;
    }

    /*
     * Must have a delim or another right brace following, unless
     * we have reached nest_level 0, where this won't matter.
 */
    expect_delim = true;
    break;

   case ATOK_DELIM:
    if (!expect_delim)
     ereturn(escontext, false,
       (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
        errmsg("malformed array literal: \"%s\"", origStr),
        errdetail("Unexpected \"%c\" character.",
            typdelim)));
    expect_delim = false;
    break;

   case ATOK_ELEM:
   case ATOK_ELEM_NULL:
    /* Can't get here with nest_level == 0 */
    Assert(nest_level > 0);

    /* Disallow consecutive ELEM tokens */
    if (expect_delim)
     ereturn(escontext, false,
       (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
        errmsg("malformed array literal: \"%s\"", origStr),
        errdetail("Unexpected array element.")));

    /* Enlarge the values/nulls arrays if needed */
    if (nitems >= maxitems)
    {
     if (maxitems >= MaxArraySize)
      ereturn(escontext, false,
        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
         errmsg("array size exceeds the maximum allowed (%d)",
          (int) MaxArraySize)));
     maxitems = Min(maxitems * 2, MaxArraySize);
     values = repalloc_array(values, Datum, maxitems);
     nulls = repalloc_array(nulls, bool, maxitems);
    }

    /* Read the element's value, or check that NULL is allowed */
    if (!InputFunctionCallSafe(inputproc,
             (tok == ATOK_ELEM_NULL) ? NULL : elembuf.data,
             typioparam, typmod,
             escontext,
             &values[nitems]))
     return false;
    nulls[nitems] = (tok == ATOK_ELEM_NULL);
    nitems++;

    /*
     * Once we have found an element, the number of dimensions can
     * no longer increase, and subsequent elements must all be at
     * the same nesting depth.
 */
    ndim_frozen = true;
    if (nest_level != ndim)
     goto dimension_error;
    /* Count the new element */
    nelems[nest_level - 1]++;

    /* Must have a delim or a right brace following */
    expect_delim = true;
    break;

   case ATOK_ERROR:
    return false;
  }
 } while (nest_level > 0);

 /* Clean up and return results */
 pfree(elembuf.data);

 *ndim_p = ndim;
 *nitems_p = nitems;
 *values_p = values;
 *nulls_p = nulls;
 return true;

dimension_error:
 if (dimensions_specified)
  ereturn(escontext, false,
    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     errmsg("malformed array literal: \"%s\"", origStr),
     errdetail("Specified array dimensions do not match array contents.")));
 else
  ereturn(escontext, false,
    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     errmsg("malformed array literal: \"%s\"", origStr),
     errdetail("Multidimensional arrays must have sub-arrays with matching dimensions.")));
}

/*
 * ReadArrayToken
 *  read one token from an array value string
 *
 * Starts scanning from *srcptr.  On non-error return, *srcptr is
 * advanced past the token.
 *
 * If the token is ATOK_ELEM, the de-escaped string is returned in elembuf.
 */
static ArrayToken
ReadArrayToken(char **srcptr, StringInfo elembuf, char typdelim,
      const char *origStr, Node *escontext)
{
 char    *p = *srcptr;
 int   dstlen;
 bool  has_escapes;

 resetStringInfo(elembuf);

 /* Identify token type.  Loop advances over leading whitespace. */
 for (;;)
 {
  switch (*p)
  {
   case '\0':
    goto ending_error;
   case '{':
    *srcptr = p + 1;
    return ATOK_LEVEL_START;
   case '}':
    *srcptr = p + 1;
    return ATOK_LEVEL_END;
   case '"':
    p++;
    goto quoted_element;
   default:
    if (*p == typdelim)
    {
     *srcptr = p + 1;
     return ATOK_DELIM;
    }
    if (scanner_isspace(*p))
    {
     p++;
     continue;
    }
    goto unquoted_element;
  }
 }

quoted_element:
 for (;;)
 {
  switch (*p)
  {
   case '\0':
    goto ending_error;
   case '\\':
    /* Skip backslash, copy next character as-is. */
    p++;
    if (*p == '\0')
     goto ending_error;
    appendStringInfoChar(elembuf, *p++);
    break;
   case '"':

    /*
     * If next non-whitespace isn't typdelim or a brace, complain
     * about incorrect quoting.  While we could leave such cases
     * to be detected as incorrect token sequences, the resulting
     * message wouldn't be as helpful.  (We could also give the
     * incorrect-quoting error when next is '{', but treating that
     * as a token sequence error seems better.)
 */
    while (*(++p) != '\0')
    {
     if (*p == typdelim || *p == '}' || *p == '{')
     {
      *srcptr = p;
      return ATOK_ELEM;
     }
     if (!scanner_isspace(*p))
      ereturn(escontext, ATOK_ERROR,
        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
         errmsg("malformed array literal: \"%s\"", origStr),
         errdetail("Incorrectly quoted array element.")));
    }
    goto ending_error;
   default:
    appendStringInfoChar(elembuf, *p++);
    break;
  }
 }

unquoted_element:

 /*
  * We don't include trailing whitespace in the result.  dstlen tracks how
  * much of the output string is known to not be trailing whitespace.
 */
 dstlen = 0;
 has_escapes = false;
 for (;;)
 {
  switch (*p)
  {
   case '\0':
    goto ending_error;
   case '{':
    ereturn(escontext, ATOK_ERROR,
      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
       errmsg("malformed array literal: \"%s\"", origStr),
       errdetail("Unexpected \"%c\" character.",
           '{')));
   case '"':
    /* Must double-quote all or none of an element. */
    ereturn(escontext, ATOK_ERROR,
      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
       errmsg("malformed array literal: \"%s\"", origStr),
       errdetail("Incorrectly quoted array element.")));
   case '\\':
    /* Skip backslash, copy next character as-is. */
    p++;
    if (*p == '\0')
     goto ending_error;
    appendStringInfoChar(elembuf, *p++);
    dstlen = elembuf->len; /* treat it as non-whitespace */
    has_escapes = true;
    break;
   default:
    /* End of elem? */
    if (*p == typdelim || *p == '}')
    {
     /* hack: truncate the output string to dstlen */
     elembuf->data[dstlen] = '\0';
     elembuf->len = dstlen;
     *srcptr = p;
     /* Check if it's unquoted "NULL" */
     if (Array_nulls && !has_escapes &&
      pg_strcasecmp(elembuf->data, "NULL") == 0)
      return ATOK_ELEM_NULL;
     else
      return ATOK_ELEM;
    }
    appendStringInfoChar(elembuf, *p);
    if (!scanner_isspace(*p))
     dstlen = elembuf->len;
    p++;
    break;
  }
 }

ending_error:
 ereturn(escontext, ATOK_ERROR,
   (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
    errmsg("malformed array literal: \"%s\"", origStr),
    errdetail("Unexpected end of input.")));
}

/*
 * Copy data into an array object from a temporary array of Datums.
 *
 * array: array object (with header fields already filled in)
 * values: array of Datums to be copied
 * nulls: array of is-null flags (can be NULL if no nulls)
 * nitems: number of Datums to be copied
 * typbyval, typlen, typalign: info about element datatype
 * freedata: if true and element type is pass-by-ref, pfree data values
 * referenced by Datums after copying them.
 *
 * If the input data is of varlena type, the caller must have ensured that
 * the values are not toasted.  (Doing it here doesn't work since the
 * caller has already allocated space for the array...)
 */
void
CopyArrayEls(ArrayType *array,
    Datum *values,
    bool *nulls,
    int nitems,
    int typlen,
    bool typbyval,
    char typalign,
    bool freedata)
{
 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;
}

/*
 * array_out :
 *     takes the internal representation of an array and returns a string
 *    containing the array in its external format.
 */
Datum
array_out(PG_FUNCTION_ARGS)
{
 AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
 Oid   element_type = AARR_ELEMTYPE(v);
 int   typlen;
 bool  typbyval;
 char  typalign;
 char  typdelim;
 char    *p,
      *tmp,
      *retval,
     **values,
    dims_str[(MAXDIM * 33) + 2];

 /*
  * 33 per dim since we assume 15 digits per number + ':' +'[]'
  *
  * +2 allows for assignment operator + trailing null
 */
 bool    *needquotes,
    needdims = false;
 size_t  overall_length;
 int   nitems,
    i,
    j,
    k,
    indx[MAXDIM];
 int   ndim,
      *dims,
      *lb;
 array_iter iter;
 ArrayMetaState *my_extra;

 /*
  * We arrange to look up info about element type, including its output
  * conversion proc, only once per series of calls, assuming the element
  * type doesn't change underneath us.
 */
 my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
 if (my_extra == NULL)
 {
  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
               sizeof(ArrayMetaState));
  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
  my_extra->element_type = ~element_type;
 }

 if (my_extra->element_type != element_type)
 {
  /*
   * Get info about element type, including its output conversion proc
 */
  get_type_io_data(element_type, IOFunc_output,
       &my_extra->typlen, &my_extra->typbyval,
       &my_extra->typalign, &my_extra->typdelim,
       &my_extra->typioparam, &my_extra->typiofunc);
  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
       fcinfo->flinfo->fn_mcxt);
  my_extra->element_type = element_type;
 }
 typlen = my_extra->typlen;
 typbyval = my_extra->typbyval;
 typalign = my_extra->typalign;
 typdelim = my_extra->typdelim;

 ndim = AARR_NDIM(v);
 dims = AARR_DIMS(v);
 lb = AARR_LBOUND(v);
 nitems = ArrayGetNItems(ndim, dims);

 if (nitems == 0)
 {
  retval = pstrdup("{}");
  PG_RETURN_CSTRING(retval);
 }

 /*
  * we will need to add explicit dimensions if any dimension has a lower
  * bound other than one
 */
 for (i = 0; i < ndim; i++)
 {
  if (lb[i] != 1)
  {
   needdims = true;
   break;
  }
 }

 /*
  * Convert all values to string form, count total space needed (including
  * any overhead such as escaping backslashes), and detect whether each
  * item needs double quotes.
 */
 values = (char **) palloc(nitems * sizeof(char *));
 needquotes = (bool *) palloc(nitems * sizeof(bool));
 overall_length = 0;

 array_iter_setup(&iter, v);

 for (i = 0; i < nitems; i++)
 {
  Datum  itemvalue;
  bool  isnull;
  bool  needquote;

  /* Get source element, checking for NULL */
  itemvalue = array_iter_next(&iter, &isnull, i,
         typlen, typbyval, typalign);

  if (isnull)
  {
   values[i] = pstrdup("NULL");
   overall_length += 4;
   needquote = false;
  }
  else
  {
   values[i] = OutputFunctionCall(&my_extra->proc, itemvalue);

   /* count data plus backslashes; detect chars needing quotes */
   if (values[i][0] == '\0')
    needquote = true; /* force quotes for empty string */
   else if (pg_strcasecmp(values[i], "NULL") == 0)
    needquote = true; /* force quotes for literal NULL */
   else
    needquote = false;

   for (tmp = values[i]; *tmp != '\0'; tmp++)
   {
    char  ch = *tmp;

    overall_length += 1;
    if (ch == '"' || ch == '\\')
    {
     needquote = true;
     overall_length += 1;
    }
    else if (ch == '{' || ch == '}' || ch == typdelim ||
       scanner_isspace(ch))
     needquote = true;
   }
  }

  needquotes[i] = needquote;

  /* Count the pair of double quotes, if needed */
  if (needquote)
   overall_length += 2;
  /* and the comma (or other typdelim delimiter) */
  overall_length += 1;
 }

 /*
  * The very last array element doesn't have a typdelim delimiter after it,
  * but that's OK; that space is needed for the trailing '\0'.
  *
  * Now count total number of curly brace pairs in output string.
 */
 for (i = j = 0, k = 1; i < ndim; i++)
 {
  j += k, k *= dims[i];
 }
 overall_length += 2 * j;

 /* Format explicit dimensions if required */
 dims_str[0] = '\0';
 if (needdims)
 {
  char    *ptr = dims_str;

  for (i = 0; i < ndim; i++)
  {
   sprintf(ptr, "[%d:%d]", lb[i], lb[i] + dims[i] - 1);
   ptr += strlen(ptr);
  }
  *ptr++ = *ASSGN;
  *ptr = '\0';
  overall_length += ptr - dims_str;
 }

 /* Now construct the output string */
 retval = (char *) palloc(overall_length);
 p = retval;

#define APPENDSTR(str) (strcpy(p, (str)), p += strlen(p))
#define APPENDCHAR(ch) (*p++ = (ch), *p = '\0')

 if (needdims)
  APPENDSTR(dims_str);
 APPENDCHAR('{');
 for (i = 0; i < ndim; i++)
  indx[i] = 0;
 j = 0;
 k = 0;
 do
 {
  for (i = j; i < ndim - 1; i++)
   APPENDCHAR('{');

  if (needquotes[k])
  {
   APPENDCHAR('"');
   for (tmp = values[k]; *tmp; tmp++)
   {
    char  ch = *tmp;

    if (ch == '"' || ch == '\\')
     *p++ = '\\';
    *p++ = ch;
   }
   *p = '\0';
   APPENDCHAR('"');
  }
  else
   APPENDSTR(values[k]);
  pfree(values[k++]);

  for (i = ndim - 1; i >= 0; i--)
  {
   if (++(indx[i]) < dims[i])
   {
    APPENDCHAR(typdelim);
    break;
   }
   else
   {
    indx[i] = 0;
    APPENDCHAR('}');
   }
  }
  j = i;
 } while (j != -1);

#undef APPENDSTR
#undef APPENDCHAR

 /* Assert that we calculated the string length accurately */
 Assert(overall_length == (p - retval + 1));

 pfree(values);
 pfree(needquotes);

 PG_RETURN_CSTRING(retval);
}

/*
 * array_recv :
 *    converts an array from the external binary format to
 *    its internal format.
 *
 * return value :
 *    the internal representation of the input array
 */
Datum
array_recv(PG_FUNCTION_ARGS)
{
 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
 Oid   spec_element_type = PG_GETARG_OID(1); /* type of an array
 * element */
 int32  typmod = PG_GETARG_INT32(2); /* typmod for array elements */
 Oid   element_type;
 int   typlen;
 bool  typbyval;
 char  typalign;
 Oid   typioparam;
 int   i,
    nitems;
 Datum    *dataPtr;
 bool    *nullsPtr;
 bool  hasnulls;
 int32  nbytes;
 int32  dataoffset;
 ArrayType  *retval;
 int   ndim,
    flags,
    dim[MAXDIM],
    lBound[MAXDIM];
 ArrayMetaState *my_extra;

 /* Get the array header information */
 ndim = pq_getmsgint(buf, 4);
 if (ndim < 0)    /* we do allow zero-dimension arrays */
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
     errmsg("invalid number of dimensions: %d", ndim)));
 if (ndim > MAXDIM)
  ereport(ERROR,
    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
      ndim, MAXDIM)));

 flags = pq_getmsgint(buf, 4);
 if (flags != 0 && flags != 1)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
     errmsg("invalid array flags")));

 /* Check element type recorded in the data */
 element_type = pq_getmsgint(buf, sizeof(Oid));

 /*
  * From a security standpoint, it doesn't matter whether the input's
  * element type matches what we expect: the element type's receive
  * function has to be robust enough to cope with invalid data.  However,
  * from a user-friendliness standpoint, it's nicer to complain about type
  * mismatches than to throw "improper binary format" errors.  But there's
  * a problem: only built-in types have OIDs that are stable enough to
  * believe that a mismatch is a real issue.  So complain only if both OIDs
  * are in the built-in range.  Otherwise, carry on with the element type
  * we "should" be getting.
 */
 if (element_type != spec_element_type)
 {
  if (element_type < FirstGenbkiObjectId &&
   spec_element_type < FirstGenbkiObjectId)
   ereport(ERROR,
     (errcode(ERRCODE_DATATYPE_MISMATCH),
      errmsg("binary data has array element type %u (%s) instead of expected %u (%s)",
       element_type,
       format_type_extended(element_type, -1,
             FORMAT_TYPE_ALLOW_INVALID),
       spec_element_type,
       format_type_extended(spec_element_type, -1,
             FORMAT_TYPE_ALLOW_INVALID))));
  element_type = spec_element_type;
 }

 for (i = 0; i < ndim; i++)
 {
  dim[i] = pq_getmsgint(buf, 4);
  lBound[i] = pq_getmsgint(buf, 4);
 }

 /* This checks for overflow of array dimensions */
 nitems = ArrayGetNItems(ndim, dim);
 ArrayCheckBounds(ndim, dim, lBound);

 /*
  * We arrange to look up info about element type, including its receive
  * conversion proc, only once per series of calls, assuming the element
  * type doesn't change underneath us.
 */
 my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
 if (my_extra == NULL)
 {
  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
               sizeof(ArrayMetaState));
  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
  my_extra->element_type = ~element_type;
 }

 if (my_extra->element_type != element_type)
 {
  /* Get info about element type, including its receive proc */
  get_type_io_data(element_type, IOFunc_receive,
       &my_extra->typlen, &my_extra->typbyval,
       &my_extra->typalign, &my_extra->typdelim,
       &my_extra->typioparam, &my_extra->typiofunc);
  if (!OidIsValid(my_extra->typiofunc))
   ereport(ERROR,
     (errcode(ERRCODE_UNDEFINED_FUNCTION),
      errmsg("no binary input function available for type %s",
       format_type_be(element_type))));
  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
       fcinfo->flinfo->fn_mcxt);
  my_extra->element_type = element_type;
 }

 if (nitems == 0)
 {
  /* Return empty array ... but not till we've validated element_type */
  PG_RETURN_ARRAYTYPE_P(construct_empty_array(element_type));
 }

 typlen = my_extra->typlen;
 typbyval = my_extra->typbyval;
 typalign = my_extra->typalign;
 typioparam = my_extra->typioparam;

 dataPtr = (Datum *) palloc(nitems * sizeof(Datum));
 nullsPtr = (bool *) palloc(nitems * sizeof(bool));
 ReadArrayBinary(buf, nitems,
     &my_extra->proc, typioparam, typmod,
     typlen, typbyval, typalign,
     dataPtr, nullsPtr,
     &hasnulls, &nbytes);
 if (hasnulls)
 {
  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
  nbytes += dataoffset;
 }
 else
 {
  dataoffset = 0;   /* marker for no null bitmap */
  nbytes += ARR_OVERHEAD_NONULLS(ndim);
 }
 retval = (ArrayType *) palloc0(nbytes);
 SET_VARSIZE(retval, nbytes);
 retval->ndim = ndim;
 retval->dataoffset = dataoffset;
 retval->elemtype = element_type;
 memcpy(ARR_DIMS(retval), dim, ndim * sizeof(int));
 memcpy(ARR_LBOUND(retval), lBound, ndim * sizeof(int));

 CopyArrayEls(retval,
     dataPtr, nullsPtr, nitems,
     typlen, typbyval, typalign,
     true);

 pfree(dataPtr);
 pfree(nullsPtr);

 PG_RETURN_ARRAYTYPE_P(retval);
}

/*
 * ReadArrayBinary:
 *  collect the data elements of an array being read in binary style.
 *
 * Inputs:
 * buf: the data buffer to read from.
 * nitems: total number of array elements (already read).
 * receiveproc: type-specific receive procedure for element datatype.
 * typioparam, typmod: auxiliary values to pass to receiveproc.
 * typlen, typbyval, typalign: storage parameters of element datatype.
 *
 * Outputs:
 * values[]: filled with converted data values.
 * nulls[]: filled with is-null markers.
 * *hasnulls: set true iff there are any null elements.
 * *nbytes: set to total size of data area needed (including alignment
 *  padding but not including array header overhead).
 *
 * Note that values[] and nulls[] are allocated by the caller, and must have
 * nitems elements.
 */
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)
{
 int   i;
 bool  hasnull;
 int32  totbytes;

 for (i = 0; i < nitems; i++)
 {
  int   itemlen;
  StringInfoData elem_buf;

  /* Get and check the item length */
  itemlen = pq_getmsgint(buf, 4);
  if (itemlen < -1 || itemlen > (buf->len - buf->cursor))
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
      errmsg("insufficient data left in message")));

  if (itemlen == -1)
  {
   /* -1 length means NULL */
   values[i] = ReceiveFunctionCall(receiveproc, NULL,
           typioparam, typmod);
   nulls[i] = true;
   continue;
  }

  /*
   * Rather than copying data around, we just initialize a StringInfo
   * pointing to the correct portion of the message buffer.
 */
  initReadOnlyStringInfo(&elem_buf, &buf->data[buf->cursor], itemlen);

  buf->cursor += itemlen;

  /* Now call the element's receiveproc */
  values[i] = ReceiveFunctionCall(receiveproc, &elem_buf,
          typioparam, typmod);
  nulls[i] = false;

  /* Trouble if it didn't eat the whole buffer */
  if (elem_buf.cursor != itemlen)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
      errmsg("improper binary format in array element %d",
       i + 1)));
 }

 /*
  * Check for nulls, compute total data space needed
 */
 hasnull = false;
 totbytes = 0;
 for (i = 0; i < nitems; i++)
 {
  if (nulls[i])
   hasnull = true;
  else
  {
   /* let's just make sure data is not toasted */
   if (typlen == -1)
    values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
   totbytes = att_addlength_datum(totbytes, typlen, values[i]);
   totbytes = att_align_nominal(totbytes, typalign);
   /* check for overflow of total request */
   if (!AllocSizeIsValid(totbytes))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxAllocSize)));
  }
 }
 *hasnulls = hasnull;
 *nbytes = totbytes;
}


/*
 * array_send :
 *    takes the internal representation of an array and returns a bytea
 *    containing the array in its external binary format.
 */
Datum
array_send(PG_FUNCTION_ARGS)
{
 AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
 Oid   element_type = AARR_ELEMTYPE(v);
 int   typlen;
 bool  typbyval;
 char  typalign;
 int   nitems,
    i;
 int   ndim,
      *dim,
      *lb;
 StringInfoData buf;
 array_iter iter;
 ArrayMetaState *my_extra;

 /*
  * We arrange to look up info about element type, including its send
  * conversion proc, only once per series of calls, assuming the element
  * type doesn't change underneath us.
 */
 my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
 if (my_extra == NULL)
 {
  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
               sizeof(ArrayMetaState));
  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
  my_extra->element_type = ~element_type;
 }

 if (my_extra->element_type != element_type)
 {
  /* Get info about element type, including its send proc */
  get_type_io_data(element_type, IOFunc_send,
       &my_extra->typlen, &my_extra->typbyval,
       &my_extra->typalign, &my_extra->typdelim,
       &my_extra->typioparam, &my_extra->typiofunc);
  if (!OidIsValid(my_extra->typiofunc))
   ereport(ERROR,
     (errcode(ERRCODE_UNDEFINED_FUNCTION),
      errmsg("no binary output function available for type %s",
       format_type_be(element_type))));
  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
       fcinfo->flinfo->fn_mcxt);
  my_extra->element_type = element_type;
 }
 typlen = my_extra->typlen;
 typbyval = my_extra->typbyval;
 typalign = my_extra->typalign;

 ndim = AARR_NDIM(v);
 dim = AARR_DIMS(v);
 lb = AARR_LBOUND(v);
 nitems = ArrayGetNItems(ndim, dim);

 pq_begintypsend(&buf);

 /* Send the array header information */
 pq_sendint32(&buf, ndim);
 pq_sendint32(&buf, AARR_HASNULL(v) ? 1 : 0);
 pq_sendint32(&buf, element_type);
 for (i = 0; i < ndim; i++)
 {
  pq_sendint32(&buf, dim[i]);
  pq_sendint32(&buf, lb[i]);
 }

 /* Send the array elements using the element's own sendproc */
 array_iter_setup(&iter, v);

 for (i = 0; i < nitems; i++)
 {
  Datum  itemvalue;
  bool  isnull;

  /* Get source element, checking for NULL */
  itemvalue = array_iter_next(&iter, &isnull, i,
         typlen, typbyval, typalign);

  if (isnull)
  {
   /* -1 length means a NULL */
   pq_sendint32(&buf, -1);
  }
  else
  {
   bytea    *outputbytes;

   outputbytes = SendFunctionCall(&my_extra->proc, itemvalue);
   pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
   pq_sendbytes(&buf, VARDATA(outputbytes),
       VARSIZE(outputbytes) - VARHDRSZ);
   pfree(outputbytes);
  }
 }

 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

/*
 * array_ndims :
 *    returns the number of dimensions of the array pointed to by "v"
 */
Datum
array_ndims(PG_FUNCTION_ARGS)
{
 AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);

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

 PG_RETURN_INT32(AARR_NDIM(v));
}

/*
 * array_dims :
 *    returns the dimensions of the array pointed to by "v", as a "text"
 */
Datum
array_dims(PG_FUNCTION_ARGS)
{
 AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
 char    *p;
 int   i;
 int     *dimv,
      *lb;

 /*
  * 33 since we assume 15 digits per number + ':' +'[]'
  *
  * +1 for trailing null
 */
 char  buf[MAXDIM * 33 + 1];

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

 dimv = AARR_DIMS(v);
 lb = AARR_LBOUND(v);

 p = buf;
 for (i = 0; i < AARR_NDIM(v); i++)
 {
  sprintf(p, "[%d:%d]", lb[i], dimv[i] + lb[i] - 1);
  p += strlen(p);
 }

 PG_RETURN_TEXT_P(cstring_to_text(buf));
}

/*
 * array_lower :
 *  returns the lower dimension, of the DIM requested, for
 *  the array pointed to by "v", as an int4
 */
Datum
array_lower(PG_FUNCTION_ARGS)
{
 AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
 int   reqdim = PG_GETARG_INT32(1);
 int     *lb;
 int   result;

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

 /* Sanity check: was the requested dim valid */
 if (reqdim <= 0 || reqdim > AARR_NDIM(v))
  PG_RETURN_NULL();

 lb = AARR_LBOUND(v);
 result = lb[reqdim - 1];

 PG_RETURN_INT32(result);
}

/*
 * array_upper :
 *  returns the upper dimension, of the DIM requested, for
 *  the array pointed to by "v", as an int4
 */
Datum
array_upper(PG_FUNCTION_ARGS)
{
 AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
 int   reqdim = PG_GETARG_INT32(1);
 int     *dimv,
      *lb;
 int   result;

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

 /* Sanity check: was the requested dim valid */
 if (reqdim <= 0 || reqdim > AARR_NDIM(v))
  PG_RETURN_NULL();

 lb = AARR_LBOUND(v);
 dimv = AARR_DIMS(v);

 result = dimv[reqdim - 1] + lb[reqdim - 1] - 1;

 PG_RETURN_INT32(result);
}

/*
 * array_length :
 *  returns the length, of the dimension requested, for
 *  the array pointed to by "v", as an int4
 */
Datum
array_length(PG_FUNCTION_ARGS)
{
 AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
 int   reqdim = PG_GETARG_INT32(1);
 int     *dimv;
 int   result;

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

 /* Sanity check: was the requested dim valid */
 if (reqdim <= 0 || reqdim > AARR_NDIM(v))
  PG_RETURN_NULL();

 dimv = AARR_DIMS(v);

 result = dimv[reqdim - 1];

 PG_RETURN_INT32(result);
}

/*
 * array_cardinality:
 *  returns the total number of elements in an array
 */
Datum
array_cardinality(PG_FUNCTION_ARGS)
{
 AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);

 PG_RETURN_INT32(ArrayGetNItems(AARR_NDIM(v), AARR_DIMS(v)));
}


/*
 * array_get_element :
 *   This routine takes an array datum and a subscript array and returns
 *   the referenced item as a Datum.  Note that for a pass-by-reference
 *   datatype, the returned Datum is a pointer into the array object.
 *
 * This handles both ordinary varlena arrays and fixed-length arrays.
 *
 * Inputs:
 * arraydatum: the array object (mustn't be NULL)
 * nSubscripts: number of subscripts supplied
 * indx[]: the subscript values
 * arraytyplen: pg_type.typlen for the array type
 * elmlen: pg_type.typlen for the array's element type
 * elmbyval: pg_type.typbyval for the array's element type
 * elmalign: pg_type.typalign for the array's element type
 *
 * Outputs:
 * The return value is the element Datum.
 * *isNull is set to indicate whether the element is NULL.
 */
Datum
array_get_element(Datum arraydatum,
      int nSubscripts,
      int *indx,
      int arraytyplen,
      int elmlen,
      bool elmbyval,
      char elmalign,
      bool *isNull)
{
 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);
}

/*
 * Implementation of array_get_element() for an expanded array
 */
static Datum
array_get_element_expanded(Datum arraydatum,
         int nSubscripts, int *indx,
         int arraytyplen,
         int elmlen, bool elmbyval, char elmalign,
         bool *isNull)
{
 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];
}

/*
 * array_get_slice :
 *     This routine takes an array and a range of indices (upperIndx and
 *     lowerIndx), creates a new array structure for the referred elements
 *     and returns a pointer to it.
 *
 * This handles both ordinary varlena arrays and fixed-length arrays.
 *
 * Inputs:
 * arraydatum: the array object (mustn't be NULL)
 * nSubscripts: number of subscripts supplied (must be same for upper/lower)
 * upperIndx[]: the upper subscript values
 * lowerIndx[]: the lower subscript values
 * upperProvided[]: true for provided upper subscript values
 * lowerProvided[]: true for provided lower subscript values
 * arraytyplen: pg_type.typlen for the array type
 * elmlen: pg_type.typlen for the array's element type
 * elmbyval: pg_type.typbyval for the array's element type
 * elmalign: pg_type.typalign for the array's element type
 *
 * Outputs:
 * The return value is the new array Datum (it's never NULL)
 *
 * Omitted upper and lower subscript values are replaced by the corresponding
 * array bound.
 *
 * NOTE: we assume it is OK to scribble on the provided subscript arrays
 * lowerIndx[] and upperIndx[]; also, these arrays must be of size MAXDIM
 * even when nSubscripts is less.  These are generally just temporaries.
 */
Datum
array_get_slice(Datum arraydatum,
    int nSubscripts,
    int *upperIndx,
    int *lowerIndx,
    bool *upperProvided,
    bool *lowerProvided,
    int arraytyplen,
    int elmlen,
    bool elmbyval,
    char elmalign)
{
 ArrayType  *array;
 ArrayType  *newarray;
 int   i,
    ndim,
      *dim,
      *lb,
      *newlb;
 int   fixedDim[1],
    fixedLb[1];
 Oid   elemtype;
 char    *arraydataptr;
 bits8    *arraynullsptr;
 int32  dataoffset;
 int   bytes,
    span[MAXDIM];

 if (arraytyplen > 0)
 {
  /*
   * fixed-length arrays -- currently, cannot slice these because parser
   * labels output as being of the fixed-length array type! Code below
   * shows how we could support it if the parser were changed to label
   * output as a suitable varlena array type.
 */
  ereport(ERROR,
    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     errmsg("slices of fixed-length arrays not implemented")));

  /*
   * fixed-length arrays -- these are assumed to be 1-d, 0-based
   *
   * XXX where would we get the correct ELEMTYPE from?
 */
  ndim = 1;
  fixedDim[0] = arraytyplen / elmlen;
  fixedLb[0] = 0;
  dim = fixedDim;
  lb = fixedLb;
  elemtype = InvalidOid; /* XXX */
  arraydataptr = (char *) DatumGetPointer(arraydatum);
  arraynullsptr = NULL;
 }
 else
 {
  /* detoast input array if necessary */
  array = DatumGetArrayTypeP(arraydatum);

  ndim = ARR_NDIM(array);
  dim = ARR_DIMS(array);
  lb = ARR_LBOUND(array);
  elemtype = ARR_ELEMTYPE(array);
  arraydataptr = ARR_DATA_PTR(array);
  arraynullsptr = ARR_NULLBITMAP(array);
 }

 /*
  * Check provided subscripts.  A slice exceeding the current array limits
  * is silently truncated to the array limits.  If we end up with an empty
  * slice, return an empty array.
 */
 if (ndim < nSubscripts || ndim <= 0 || ndim > MAXDIM)
  return PointerGetDatum(construct_empty_array(elemtype));

 for (i = 0; i < nSubscripts; i++)
 {
  if (!lowerProvided[i] || lowerIndx[i] < lb[i])
   lowerIndx[i] = lb[i];
  if (!upperProvided[i] || upperIndx[i] >= (dim[i] + lb[i]))
   upperIndx[i] = dim[i] + lb[i] - 1;
  if (lowerIndx[i] > upperIndx[i])
   return PointerGetDatum(construct_empty_array(elemtype));
 }
 /* fill any missing subscript positions with full array range */
 for (; i < ndim; i++)
 {
  lowerIndx[i] = lb[i];
  upperIndx[i] = dim[i] + lb[i] - 1;
  if (lowerIndx[i] > upperIndx[i])
   return PointerGetDatum(construct_empty_array(elemtype));
 }

 mda_get_range(ndim, span, lowerIndx, upperIndx);

 bytes = array_slice_size(arraydataptr, arraynullsptr,
        ndim, dim, lb,
        lowerIndx, upperIndx,
        elmlen, elmbyval, elmalign);

 /*
  * Currently, we put a null bitmap in the result if the source has one;
  * could be smarter ...
 */
 if (arraynullsptr)
 {
  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, ArrayGetNItems(ndim, span));
  bytes += dataoffset;
 }
 else
 {
  dataoffset = 0;   /* marker for no null bitmap */
  bytes += ARR_OVERHEAD_NONULLS(ndim);
 }

 newarray = (ArrayType *) palloc0(bytes);
 SET_VARSIZE(newarray, bytes);
 newarray->ndim = ndim;
 newarray->dataoffset = dataoffset;
 newarray->elemtype = elemtype;
 memcpy(ARR_DIMS(newarray), span, ndim * sizeof(int));

 /*
  * Lower bounds of the new array are set to 1.  Formerly (before 7.3) we
  * copied the given lowerIndx values ... but that seems confusing.
 */
 newlb = ARR_LBOUND(newarray);
 for (i = 0; i < ndim; i++)
  newlb[i] = 1;

 array_extract_slice(newarray,
      ndim, dim, lb,
      arraydataptr, arraynullsptr,
      lowerIndx, upperIndx,
      elmlen, elmbyval, elmalign);

 return PointerGetDatum(newarray);
}

/*
 * array_set_element :
 *    This routine sets the value of one array element (specified by
 *    a subscript array) to a new value specified by "dataValue".
 *
 * This handles both ordinary varlena arrays and fixed-length arrays.
 *
 * Inputs:
 * arraydatum: the initial array object (mustn't be NULL)
 * nSubscripts: number of subscripts supplied
 * indx[]: the subscript values
 * dataValue: the datum to be inserted at the given position
 * isNull: whether dataValue is NULL
 * arraytyplen: pg_type.typlen for the array type
 * elmlen: pg_type.typlen for the array's element type
 * elmbyval: pg_type.typbyval for the array's element type
 * elmalign: pg_type.typalign for the array's element type
 *
 * Result:
 *    A new array is returned, just like the old except for the one
 *    modified entry.  The original array object is not changed,
 *    unless what is passed is a read-write reference to an expanded
 *    array object; in that case the expanded array is updated in-place.
 *
 * For one-dimensional arrays only, we allow the array to be extended
 * by assigning to a position outside the existing subscript range; any
 * positions between the existing elements and the new one are set to NULLs.
 * (XXX TODO: allow a corresponding behavior for multidimensional arrays)
 *
 * NOTE: For assignments, we throw an error for invalid subscripts etc,
 * rather than returning a NULL as the fetch operations do.
 */
Datum
array_set_element(Datum arraydatum,
      int nSubscripts,
      int *indx,
      Datum dataValue,
      bool isNull,
      int arraytyplen,
      int elmlen,
      bool elmbyval,
      char elmalign)
{
 ArrayType  *array;
 ArrayType  *newarray;
 int   i,
    ndim,
    dim[MAXDIM],
    lb[MAXDIM],
    offset;
 char    *elt_ptr;
 bool  newhasnulls;
 bits8    *oldnullbitmap;
 int   oldnitems,
    newnitems,
    olddatasize,
    newsize,
    olditemlen,
    newitemlen,
    overheadlen,
    oldoverheadlen,
    addedbefore,
    addedafter,
    lenbefore,
    lenafter;

 if (arraytyplen > 0)
 {
  /*
   * fixed-length arrays -- these are assumed to be 1-d, 0-based. We
   * cannot extend them, either.
 */
  char    *resultarray;

  if (nSubscripts != 1)
   ereport(ERROR,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("wrong number of array subscripts")));

  if (indx[0] < 0 || indx[0] >= arraytyplen / elmlen)
   ereport(ERROR,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("array subscript out of range")));

  if (isNull)
   ereport(ERROR,
     (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
      errmsg("cannot assign null value to an element of a fixed-length array")));

  resultarray = (char *) palloc(arraytyplen);
  memcpy(resultarray, DatumGetPointer(arraydatum), arraytyplen);
  elt_ptr = (char *) resultarray + indx[0] * elmlen;
  ArrayCastAndSet(dataValue, elmlen, elmbyval, elmalign, elt_ptr);
  return PointerGetDatum(resultarray);
 }

 if (nSubscripts <= 0 || nSubscripts > MAXDIM)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("wrong number of array subscripts")));

 /* make sure item to be inserted is not toasted */
 if (elmlen == -1 && !isNull)
  dataValue = PointerGetDatum(PG_DETOAST_DATUM(dataValue));

 if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(arraydatum)))
 {
  /* expanded array: let's do this in a separate function */
  return array_set_element_expanded(arraydatum,
            nSubscripts,
            indx,
            dataValue,
            isNull,
            arraytyplen,
            elmlen,
            elmbyval,
            elmalign);
 }

 /* detoast input array if necessary */
 array = DatumGetArrayTypeP(arraydatum);

 ndim = ARR_NDIM(array);

 /*
  * if number of dims is zero, i.e. an empty array, create an array with
  * nSubscripts dimensions, and set the lower bounds to the supplied
  * subscripts
 */
 if (ndim == 0)
 {
  Oid   elmtype = ARR_ELEMTYPE(array);

  for (i = 0; i < nSubscripts; i++)
  {
   dim[i] = 1;
   lb[i] = indx[i];
  }

  return PointerGetDatum(construct_md_array(&dataValue, &isNull,
              nSubscripts, dim, lb,
              elmtype,
              elmlen, elmbyval, elmalign));
 }

 if (ndim != nSubscripts)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("wrong number of array subscripts")));

 /* copy dim/lb since we may modify them */
 memcpy(dim, ARR_DIMS(array), ndim * sizeof(int));
 memcpy(lb, ARR_LBOUND(array), ndim * sizeof(int));

 newhasnulls = (ARR_HASNULL(array) || isNull);
 addedbefore = addedafter = 0;

 /*
  * Check subscripts.  We assume the existing subscripts passed
  * ArrayCheckBounds, so that dim[i] + lb[i] can be computed without
  * overflow.  But we must beware of other overflows in our calculations of
  * new dim[] values.
 */
 if (ndim == 1)
 {
  if (indx[0] < lb[0])
  {
   /* addedbefore = lb[0] - indx[0]; */
   /* dim[0] += addedbefore; */
   if (pg_sub_s32_overflow(lb[0], indx[0], &addedbefore) ||
    pg_add_s32_overflow(dim[0], addedbefore, &dim[0]))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxArraySize)));
   lb[0] = indx[0];
   if (addedbefore > 1)
    newhasnulls = true; /* will insert nulls */
  }
  if (indx[0] >= (dim[0] + lb[0]))
  {
   /* addedafter = indx[0] - (dim[0] + lb[0]) + 1; */
   /* dim[0] += addedafter; */
   if (pg_sub_s32_overflow(indx[0], dim[0] + lb[0], &addedafter) ||
    pg_add_s32_overflow(addedafter, 1, &addedafter) ||
    pg_add_s32_overflow(dim[0], addedafter, &dim[0]))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxArraySize)));
   if (addedafter > 1)
    newhasnulls = true; /* will insert nulls */
  }
 }
 else
 {
  /*
   * XXX currently we do not support extending multi-dimensional arrays
   * during assignment
 */
  for (i = 0; i < ndim; i++)
  {
   if (indx[i] < lb[i] ||
    indx[i] >= (dim[i] + lb[i]))
    ereport(ERROR,
      (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
       errmsg("array subscript out of range")));
  }
 }

 /* This checks for overflow of the array dimensions */
 newnitems = ArrayGetNItems(ndim, dim);
 ArrayCheckBounds(ndim, dim, lb);

 /*
  * Compute sizes of items and areas to copy
 */
 if (newhasnulls)
  overheadlen = ARR_OVERHEAD_WITHNULLS(ndim, newnitems);
 else
  overheadlen = ARR_OVERHEAD_NONULLS(ndim);
 oldnitems = ArrayGetNItems(ndim, ARR_DIMS(array));
 oldnullbitmap = ARR_NULLBITMAP(array);
 oldoverheadlen = ARR_DATA_OFFSET(array);
 olddatasize = ARR_SIZE(array) - oldoverheadlen;
 if (addedbefore)
 {
  offset = 0;
  lenbefore = 0;
  olditemlen = 0;
  lenafter = olddatasize;
 }
 else if (addedafter)
 {
  offset = oldnitems;
  lenbefore = olddatasize;
  olditemlen = 0;
  lenafter = 0;
 }
 else
 {
  offset = ArrayGetOffset(nSubscripts, dim, lb, indx);
  elt_ptr = array_seek(ARR_DATA_PTR(array), 0, oldnullbitmap, offset,
        elmlen, elmbyval, elmalign);
  lenbefore = (int) (elt_ptr - ARR_DATA_PTR(array));
  if (array_get_isnull(oldnullbitmap, offset))
   olditemlen = 0;
  else
  {
   olditemlen = att_addlength_pointer(0, elmlen, elt_ptr);
   olditemlen = att_align_nominal(olditemlen, elmalign);
  }
  lenafter = (int) (olddatasize - lenbefore - olditemlen);
 }

 if (isNull)
  newitemlen = 0;
 else
 {
  newitemlen = att_addlength_datum(0, elmlen, dataValue);
  newitemlen = att_align_nominal(newitemlen, elmalign);
 }

 newsize = overheadlen + lenbefore + newitemlen + lenafter;

 /*
  * OK, create the new array and fill in header/dimensions
 */
 newarray = (ArrayType *) palloc0(newsize);
 SET_VARSIZE(newarray, newsize);
 newarray->ndim = ndim;
 newarray->dataoffset = newhasnulls ? overheadlen : 0;
 newarray->elemtype = ARR_ELEMTYPE(array);
 memcpy(ARR_DIMS(newarray), dim, ndim * sizeof(int));
 memcpy(ARR_LBOUND(newarray), lb, ndim * sizeof(int));

 /*
  * Fill in data
 */
 memcpy((char *) newarray + overheadlen,
     (char *) array + oldoverheadlen,
     lenbefore);
 if (!isNull)
  ArrayCastAndSet(dataValue, elmlen, elmbyval, elmalign,
      (char *) newarray + overheadlen + lenbefore);
 memcpy((char *) newarray + overheadlen + lenbefore + newitemlen,
     (char *) array + oldoverheadlen + lenbefore + olditemlen,
     lenafter);

 /*
  * Fill in nulls bitmap if needed
  *
  * Note: it's possible we just replaced the last NULL with a non-NULL, and
  * could get rid of the bitmap.  Seems not worth testing for though.
 */
 if (newhasnulls)
 {
  bits8    *newnullbitmap = ARR_NULLBITMAP(newarray);

  /* palloc0 above already marked any inserted positions as nulls */
  /* Fix the inserted value */
  if (addedafter)
   array_set_isnull(newnullbitmap, newnitems - 1, isNull);
  else
   array_set_isnull(newnullbitmap, offset, isNull);
  /* Fix the copied range(s) */
  if (addedbefore)
   array_bitmap_copy(newnullbitmap, addedbefore,
         oldnullbitmap, 0,
         oldnitems);
  else
  {
   array_bitmap_copy(newnullbitmap, 0,
         oldnullbitmap, 0,
         offset);
   if (addedafter == 0)
    array_bitmap_copy(newnullbitmap, offset + 1,
          oldnullbitmap, offset + 1,
          oldnitems - offset - 1);
  }
 }

 return PointerGetDatum(newarray);
}

/*
 * Implementation of array_set_element() for an expanded array
 *
 * Note: as with any operation on a read/write expanded object, we must
 * take pains not to leave the object in a corrupt state if we fail partway
 * through.
 */
static Datum
array_set_element_expanded(Datum arraydatum,
         int nSubscripts, int *indx,
         Datum dataValue, bool isNull,
         int arraytyplen,
         int elmlen, bool elmbyval, char elmalign)
{
 ExpandedArrayHeader *eah;
 Datum    *dvalues;
 bool    *dnulls;
 int   i,
    ndim,
    dim[MAXDIM],
    lb[MAXDIM],
    offset;
 bool  dimschanged,
    newhasnulls;
 int   addedbefore,
    addedafter;
 char    *oldValue;

 /* Convert to R/W object if not so already */
 eah = DatumGetExpandedArray(arraydatum);

 /* Sanity-check caller's info against object; we don't use it otherwise */
 Assert(arraytyplen == -1);
 Assert(elmlen == eah->typlen);
 Assert(elmbyval == eah->typbyval);
 Assert(elmalign == eah->typalign);

 /*
  * Copy dimension info into local storage.  This allows us to modify the
  * dimensions if needed, while not messing up the expanded value if we
  * fail partway through.
 */
 ndim = eah->ndims;
 Assert(ndim >= 0 && ndim <= MAXDIM);
 memcpy(dim, eah->dims, ndim * sizeof(int));
 memcpy(lb, eah->lbound, ndim * sizeof(int));
 dimschanged = false;

 /*
  * if number of dims is zero, i.e. an empty array, create an array with
  * nSubscripts dimensions, and set the lower bounds to the supplied
  * subscripts.
 */
 if (ndim == 0)
 {
  /*
   * Allocate adequate space for new dimension info.  This is harmless
   * if we fail later.
 */
  Assert(nSubscripts > 0 && nSubscripts <= MAXDIM);
  eah->dims = (int *) MemoryContextAllocZero(eah->hdr.eoh_context,
               nSubscripts * sizeof(int));
  eah->lbound = (int *) MemoryContextAllocZero(eah->hdr.eoh_context,
              nSubscripts * sizeof(int));

  /* Update local copies of dimension info */
  ndim = nSubscripts;
  for (i = 0; i < nSubscripts; i++)
  {
   dim[i] = 0;
   lb[i] = indx[i];
  }
  dimschanged = true;
 }
 else if (ndim != nSubscripts)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("wrong number of array subscripts")));

 /*
  * Deconstruct array if we didn't already.  (Someday maybe add a special
  * case path for fixed-length, no-nulls cases, where we can overwrite an
  * element in place without ever deconstructing.  But today is not that
  * day.)
 */
 deconstruct_expanded_array(eah);

 /*
  * Copy new element into array's context, if needed (we assume it's
  * already detoasted, so no junk should be created).  Doing this before
  * we've made any significant changes ensures that our behavior is sane
  * even when the source is a reference to some element of this same array.
  * If we fail further down, this memory is leaked, but that's reasonably
  * harmless.
 */
 if (!eah->typbyval && !isNull)
 {
  MemoryContext oldcxt = MemoryContextSwitchTo(eah->hdr.eoh_context);

  dataValue = datumCopy(dataValue, false, eah->typlen);
  MemoryContextSwitchTo(oldcxt);
 }

 dvalues = eah->dvalues;
 dnulls = eah->dnulls;

 newhasnulls = ((dnulls != NULL) || isNull);
 addedbefore = addedafter = 0;

 /*
  * Check subscripts (this logic must match array_set_element).  We assume
  * the existing subscripts passed ArrayCheckBounds, so that dim[i] + lb[i]
  * can be computed without overflow.  But we must beware of other
  * overflows in our calculations of new dim[] values.
 */
 if (ndim == 1)
 {
  if (indx[0] < lb[0])
  {
   /* addedbefore = lb[0] - indx[0]; */
   /* dim[0] += addedbefore; */
   if (pg_sub_s32_overflow(lb[0], indx[0], &addedbefore) ||
    pg_add_s32_overflow(dim[0], addedbefore, &dim[0]))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxArraySize)));
   lb[0] = indx[0];
   dimschanged = true;
   if (addedbefore > 1)
    newhasnulls = true; /* will insert nulls */
  }
  if (indx[0] >= (dim[0] + lb[0]))
  {
   /* addedafter = indx[0] - (dim[0] + lb[0]) + 1; */
   /* dim[0] += addedafter; */
   if (pg_sub_s32_overflow(indx[0], dim[0] + lb[0], &addedafter) ||
    pg_add_s32_overflow(addedafter, 1, &addedafter) ||
    pg_add_s32_overflow(dim[0], addedafter, &dim[0]))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxArraySize)));
   dimschanged = true;
   if (addedafter > 1)
    newhasnulls = true; /* will insert nulls */
  }
 }
 else
 {
  /*
   * XXX currently we do not support extending multi-dimensional arrays
   * during assignment
 */
  for (i = 0; i < ndim; i++)
  {
   if (indx[i] < lb[i] ||
    indx[i] >= (dim[i] + lb[i]))
    ereport(ERROR,
      (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
       errmsg("array subscript out of range")));
  }
 }

 /* Check for overflow of the array dimensions */
 if (dimschanged)
 {
  (void) ArrayGetNItems(ndim, dim);
  ArrayCheckBounds(ndim, dim, lb);
 }

 /* Now we can calculate linear offset of target item in array */
 offset = ArrayGetOffset(nSubscripts, dim, lb, indx);

 /* Physically enlarge existing dvalues/dnulls arrays if needed */
 if (dim[0] > eah->dvalueslen)
 {
  /* We want some extra space if we're enlarging */
  int   newlen = dim[0] + dim[0] / 8;

  newlen = Max(newlen, dim[0]); /* integer overflow guard */
  eah->dvalues = dvalues = (Datum *)
   repalloc(dvalues, newlen * sizeof(Datum));
  if (dnulls)
   eah->dnulls = dnulls = (bool *)
    repalloc(dnulls, newlen * sizeof(bool));
  eah->dvalueslen = newlen;
 }

 /*
  * If we need a nulls bitmap and don't already have one, create it, being
  * sure to mark all existing entries as not null.
 */
 if (newhasnulls && dnulls == NULL)
  eah->dnulls = dnulls = (bool *)
   MemoryContextAllocZero(eah->hdr.eoh_context,
           eah->dvalueslen * sizeof(bool));

 /*
  * We now have all the needed space allocated, so we're ready to make
  * irreversible changes.  Be very wary of allowing failure below here.
 */

 /* Flattened value will no longer represent array accurately */
 eah->fvalue = NULL;
 /* And we don't know the flattened size either */
 eah->flat_size = 0;

 /* Update dimensionality info if needed */
 if (dimschanged)
 {
  eah->ndims = ndim;
  memcpy(eah->dims, dim, ndim * sizeof(int));
  memcpy(eah->lbound, lb, ndim * sizeof(int));
 }

 /* Reposition items if needed, and fill addedbefore items with nulls */
 if (addedbefore > 0)
 {
  memmove(dvalues + addedbefore, dvalues, eah->nelems * sizeof(Datum));
  for (i = 0; i < addedbefore; i++)
   dvalues[i] = (Datum) 0;
  if (dnulls)
  {
   memmove(dnulls + addedbefore, dnulls, eah->nelems * sizeof(bool));
   for (i = 0; i < addedbefore; i++)
    dnulls[i] = true;
  }
  eah->nelems += addedbefore;
 }

 /* fill addedafter items with nulls */
 if (addedafter > 0)
 {
  for (i = 0; i < addedafter; i++)
   dvalues[eah->nelems + i] = (Datum) 0;
  if (dnulls)
  {
   for (i = 0; i < addedafter; i++)
    dnulls[eah->nelems + i] = true;
  }
  eah->nelems += addedafter;
 }

 /* Grab old element value for pfree'ing, if needed. */
 if (!eah->typbyval && (dnulls == NULL || !dnulls[offset]))
  oldValue = (char *) DatumGetPointer(dvalues[offset]);
 else
  oldValue = NULL;

 /* And finally we can insert the new element. */
 dvalues[offset] = dataValue;
 if (dnulls)
  dnulls[offset] = isNull;

 /*
  * Free old element if needed; this keeps repeated element replacements
  * from bloating the array's storage.  If the pfree somehow fails, it
  * won't corrupt the array.
 */
 if (oldValue)
 {
  /* Don't try to pfree a part of the original flat array */
  if (oldValue < eah->fstartptr || oldValue >= eah->fendptr)
   pfree(oldValue);
 }

 /* Done, return standard TOAST pointer for object */
 return EOHPGetRWDatum(&eah->hdr);
}

/*
 * array_set_slice :
 *    This routine sets the value of a range of array locations (specified
 *    by upper and lower subscript values) to new values passed as
 *    another array.
 *
 * This handles both ordinary varlena arrays and fixed-length arrays.
 *
 * Inputs:
 * arraydatum: the initial array object (mustn't be NULL)
 * nSubscripts: number of subscripts supplied (must be same for upper/lower)
 * upperIndx[]: the upper subscript values
 * lowerIndx[]: the lower subscript values
 * upperProvided[]: true for provided upper subscript values
 * lowerProvided[]: true for provided lower subscript values
 * srcArrayDatum: the source for the inserted values
 * isNull: indicates whether srcArrayDatum is NULL
 * arraytyplen: pg_type.typlen for the array type
 * elmlen: pg_type.typlen for the array's element type
 * elmbyval: pg_type.typbyval for the array's element type
 * elmalign: pg_type.typalign for the array's element type
 *
 * Result:
 *    A new array is returned, just like the old except for the
 *    modified range.  The original array object is not changed.
 *
 * Omitted upper and lower subscript values are replaced by the corresponding
 * array bound.
 *
 * For one-dimensional arrays only, we allow the array to be extended
 * by assigning to positions outside the existing subscript range; any
 * positions between the existing elements and the new ones are set to NULLs.
 * (XXX TODO: allow a corresponding behavior for multidimensional arrays)
 *
 * NOTE: we assume it is OK to scribble on the provided index arrays
 * lowerIndx[] and upperIndx[]; also, these arrays must be of size MAXDIM
 * even when nSubscripts is less.  These are generally just temporaries.
 *
 * NOTE: For assignments, we throw an error for silly subscripts etc,
 * rather than returning a NULL or empty array as the fetch operations do.
 */
Datum
array_set_slice(Datum arraydatum,
    int nSubscripts,
    int *upperIndx,
    int *lowerIndx,
    bool *upperProvided,
    bool *lowerProvided,
    Datum srcArrayDatum,
    bool isNull,
    int arraytyplen,
    int elmlen,
    bool elmbyval,
    char elmalign)
{
 ArrayType  *array;
 ArrayType  *srcArray;
 ArrayType  *newarray;
 int   i,
    ndim,
    dim[MAXDIM],
    lb[MAXDIM],
    span[MAXDIM];
 bool  newhasnulls;
 int   nitems,
    nsrcitems,
    olddatasize,
    newsize,
    olditemsize,
    newitemsize,
    overheadlen,
    oldoverheadlen,
    addedbefore,
    addedafter,
    lenbefore,
    lenafter,
    itemsbefore,
    itemsafter,
    nolditems;

 /* Currently, assignment from a NULL source array is a no-op */
 if (isNull)
  return arraydatum;

 if (arraytyplen > 0)
 {
  /*
   * fixed-length arrays -- not got round to doing this...
 */
  ereport(ERROR,
    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     errmsg("updates on slices of fixed-length arrays not implemented")));
 }

 /* detoast arrays if necessary */
 array = DatumGetArrayTypeP(arraydatum);
 srcArray = DatumGetArrayTypeP(srcArrayDatum);

 /* note: we assume srcArray contains no toasted elements */

 ndim = ARR_NDIM(array);

 /*
  * if number of dims is zero, i.e. an empty array, create an array with
  * nSubscripts dimensions, and set the upper and lower bounds to the
  * supplied subscripts
 */
 if (ndim == 0)
 {
  Datum    *dvalues;
  bool    *dnulls;
  int   nelems;
  Oid   elmtype = ARR_ELEMTYPE(array);

  deconstruct_array(srcArray, elmtype, elmlen, elmbyval, elmalign,
        &dvalues, &dnulls, &nelems);

  for (i = 0; i < nSubscripts; i++)
  {
   if (!upperProvided[i] || !lowerProvided[i])
    ereport(ERROR,
      (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
       errmsg("array slice subscript must provide both boundaries"),
       errdetail("When assigning to a slice of an empty array value,"
           " slice boundaries must be fully specified.")));

   /* compute "upperIndx[i] - lowerIndx[i] + 1", detecting overflow */
   if (pg_sub_s32_overflow(upperIndx[i], lowerIndx[i], &dim[i]) ||
    pg_add_s32_overflow(dim[i], 1, &dim[i]))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxArraySize)));

   lb[i] = lowerIndx[i];
  }

  /* complain if too few source items; we ignore extras, however */
  if (nelems < ArrayGetNItems(nSubscripts, dim))
   ereport(ERROR,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("source array too small")));

  return PointerGetDatum(construct_md_array(dvalues, dnulls, nSubscripts,
              dim, lb, elmtype,
              elmlen, elmbyval, elmalign));
 }

 if (ndim < nSubscripts || ndim <= 0 || ndim > MAXDIM)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("wrong number of array subscripts")));

 /* copy dim/lb since we may modify them */
 memcpy(dim, ARR_DIMS(array), ndim * sizeof(int));
 memcpy(lb, ARR_LBOUND(array), ndim * sizeof(int));

 newhasnulls = (ARR_HASNULL(array) || ARR_HASNULL(srcArray));
 addedbefore = addedafter = 0;

 /*
  * Check subscripts.  We assume the existing subscripts passed
  * ArrayCheckBounds, so that dim[i] + lb[i] can be computed without
  * overflow.  But we must beware of other overflows in our calculations of
  * new dim[] values.
 */
 if (ndim == 1)
 {
  Assert(nSubscripts == 1);
  if (!lowerProvided[0])
   lowerIndx[0] = lb[0];
  if (!upperProvided[0])
   upperIndx[0] = dim[0] + lb[0] - 1;
  if (lowerIndx[0] > upperIndx[0])
   ereport(ERROR,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("upper bound cannot be less than lower bound")));
  if (lowerIndx[0] < lb[0])
  {
   /* addedbefore = lb[0] - lowerIndx[0]; */
   /* dim[0] += addedbefore; */
   if (pg_sub_s32_overflow(lb[0], lowerIndx[0], &addedbefore) ||
    pg_add_s32_overflow(dim[0], addedbefore, &dim[0]))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxArraySize)));
   lb[0] = lowerIndx[0];
   if (addedbefore > 1)
    newhasnulls = true; /* will insert nulls */
  }
  if (upperIndx[0] >= (dim[0] + lb[0]))
  {
   /* addedafter = upperIndx[0] - (dim[0] + lb[0]) + 1; */
   /* dim[0] += addedafter; */
   if (pg_sub_s32_overflow(upperIndx[0], dim[0] + lb[0], &addedafter) ||
    pg_add_s32_overflow(addedafter, 1, &addedafter) ||
    pg_add_s32_overflow(dim[0], addedafter, &dim[0]))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxArraySize)));
   if (addedafter > 1)
    newhasnulls = true; /* will insert nulls */
  }
 }
 else
 {
  /*
   * XXX currently we do not support extending multi-dimensional arrays
   * during assignment
 */
  for (i = 0; i < nSubscripts; i++)
  {
   if (!lowerProvided[i])
    lowerIndx[i] = lb[i];
   if (!upperProvided[i])
    upperIndx[i] = dim[i] + lb[i] - 1;
   if (lowerIndx[i] > upperIndx[i])
    ereport(ERROR,
      (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
       errmsg("upper bound cannot be less than lower bound")));
   if (lowerIndx[i] < lb[i] ||
    upperIndx[i] >= (dim[i] + lb[i]))
    ereport(ERROR,
      (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
       errmsg("array subscript out of range")));
  }
  /* fill any missing subscript positions with full array range */
  for (; i < ndim; i++)
  {
   lowerIndx[i] = lb[i];
   upperIndx[i] = dim[i] + lb[i] - 1;
   if (lowerIndx[i] > upperIndx[i])
    ereport(ERROR,
      (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
       errmsg("upper bound cannot be less than lower bound")));
  }
 }

 /* Do this mainly to check for overflow */
 nitems = ArrayGetNItems(ndim, dim);
 ArrayCheckBounds(ndim, dim, lb);

 /*
  * Make sure source array has enough entries.  Note we ignore the shape of
  * the source array and just read entries serially.
 */
 mda_get_range(ndim, span, lowerIndx, upperIndx);
 nsrcitems = ArrayGetNItems(ndim, span);
 if (nsrcitems > ArrayGetNItems(ARR_NDIM(srcArray), ARR_DIMS(srcArray)))
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("source array too small")));

 /*
  * Compute space occupied by new entries, space occupied by replaced
  * entries, and required space for new array.
 */
 if (newhasnulls)
  overheadlen = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
 else
  overheadlen = ARR_OVERHEAD_NONULLS(ndim);
 newitemsize = array_nelems_size(ARR_DATA_PTR(srcArray), 0,
         ARR_NULLBITMAP(srcArray), nsrcitems,
         elmlen, elmbyval, elmalign);
 oldoverheadlen = ARR_DATA_OFFSET(array);
 olddatasize = ARR_SIZE(array) - oldoverheadlen;
 if (ndim > 1)
 {
  /*
   * here we do not need to cope with extension of the array; it would
   * be a lot more complicated if we had to do so...
 */
  olditemsize = array_slice_size(ARR_DATA_PTR(array),
            ARR_NULLBITMAP(array),
            ndim, dim, lb,
            lowerIndx, upperIndx,
            elmlen, elmbyval, elmalign);
  lenbefore = lenafter = 0; /* keep compiler quiet */
  itemsbefore = itemsafter = nolditems = 0;
 }
 else
 {
  /*
   * here we must allow for possibility of slice larger than orig array
   * and/or not adjacent to orig array subscripts
 */
  int   oldlb = ARR_LBOUND(array)[0];
  int   oldub = oldlb + ARR_DIMS(array)[0] - 1;
  int   slicelb = Max(oldlb, lowerIndx[0]);
  int   sliceub = Min(oldub, upperIndx[0]);
  char    *oldarraydata = ARR_DATA_PTR(array);
  bits8    *oldarraybitmap = ARR_NULLBITMAP(array);

  /* count/size of old array entries that will go before the slice */
  itemsbefore = Min(slicelb, oldub + 1) - oldlb;
  lenbefore = array_nelems_size(oldarraydata, 0, oldarraybitmap,
           itemsbefore,
           elmlen, elmbyval, elmalign);
  /* count/size of old array entries that will be replaced by slice */
  if (slicelb > sliceub)
  {
   nolditems = 0;
   olditemsize = 0;
  }
  else
  {
   nolditems = sliceub - slicelb + 1;
   olditemsize = array_nelems_size(oldarraydata + lenbefore,
           itemsbefore, oldarraybitmap,
           nolditems,
           elmlen, elmbyval, elmalign);
  }
  /* count/size of old array entries that will go after the slice */
  itemsafter = oldub + 1 - Max(sliceub + 1, oldlb);
  lenafter = olddatasize - lenbefore - olditemsize;
 }

 newsize = overheadlen + olddatasize - olditemsize + newitemsize;

 newarray = (ArrayType *) palloc0(newsize);
 SET_VARSIZE(newarray, newsize);
 newarray->ndim = ndim;
 newarray->dataoffset = newhasnulls ? overheadlen : 0;
 newarray->elemtype = ARR_ELEMTYPE(array);
 memcpy(ARR_DIMS(newarray), dim, ndim * sizeof(int));
 memcpy(ARR_LBOUND(newarray), lb, ndim * sizeof(int));

 if (ndim > 1)
 {
  /*
   * here we do not need to cope with extension of the array; it would
   * be a lot more complicated if we had to do so...
 */
  array_insert_slice(newarray, array, srcArray,
         ndim, dim, lb,
         lowerIndx, upperIndx,
         elmlen, elmbyval, elmalign);
 }
 else
 {
  /* fill in data */
  memcpy((char *) newarray + overheadlen,
      (char *) array + oldoverheadlen,
      lenbefore);
  memcpy((char *) newarray + overheadlen + lenbefore,
      ARR_DATA_PTR(srcArray),
      newitemsize);
  memcpy((char *) newarray + overheadlen + lenbefore + newitemsize,
      (char *) array + oldoverheadlen + lenbefore + olditemsize,
      lenafter);
  /* fill in nulls bitmap if needed */
  if (newhasnulls)
  {
   bits8    *newnullbitmap = ARR_NULLBITMAP(newarray);
   bits8    *oldnullbitmap = ARR_NULLBITMAP(array);

   /* palloc0 above already marked any inserted positions as nulls */
   array_bitmap_copy(newnullbitmap, addedbefore,
         oldnullbitmap, 0,
         itemsbefore);
   array_bitmap_copy(newnullbitmap, lowerIndx[0] - lb[0],
         ARR_NULLBITMAP(srcArray), 0,
         nsrcitems);
   array_bitmap_copy(newnullbitmap, addedbefore + itemsbefore + nolditems,
         oldnullbitmap, itemsbefore + nolditems,
         itemsafter);
  }
 }

 return PointerGetDatum(newarray);
}

/*
 * array_ref : backwards compatibility wrapper for array_get_element
 *
 * This only works for detoasted/flattened varlena arrays, since the array
 * argument is declared as "ArrayType *".  However there's enough code like
 * that to justify preserving this API.
 */
Datum
array_ref(ArrayType *array, int nSubscripts, int *indx,
    int arraytyplen, int elmlen, bool elmbyval, char elmalign,
    bool *isNull)
{
 return array_get_element(PointerGetDatum(array), nSubscripts, indx,
        arraytyplen, elmlen, elmbyval, elmalign,
        isNull);
}

/*
 * array_set : backwards compatibility wrapper for array_set_element
 *
 * This only works for detoasted/flattened varlena arrays, since the array
 * argument and result are declared as "ArrayType *".  However there's enough
 * code like that to justify preserving this API.
 */
ArrayType *
array_set(ArrayType *array, int nSubscripts, int *indx,
    Datum dataValue, bool isNull,
    int arraytyplen, int elmlen, bool elmbyval, char elmalign)
{
 return DatumGetArrayTypeP(array_set_element(PointerGetDatum(array),
            nSubscripts, indx,
            dataValue, isNull,
            arraytyplen,
            elmlen, elmbyval, elmalign));
}

/*
 * array_map()
 *
 * Map an array through an arbitrary expression.  Return a new array with
 * the same dimensions and each source element transformed by the given,
 * already-compiled expression.  Each source element is placed in the
 * innermost_caseval/innermost_casenull fields of the ExprState.
 *
 * Parameters are:
 * * arrayd: Datum representing array argument.
 * * exprstate: ExprState representing the per-element transformation.
 * * econtext: context for expression evaluation.
 * * retType: OID of element type of output array.  This must be the same as,
 *  or binary-compatible with, the result type of the expression.  It might
 *  be different from the input array's element type.
 * * amstate: workspace for array_map.  Must be zeroed by caller before
 *  first call, and not touched after that.
 *
 * It is legitimate to pass a freshly-zeroed ArrayMapState on each call,
 * but better performance can be had if the state can be preserved across
 * a series of calls.
 *
 * NB: caller must assure that input array is not NULL.  NULL elements in
 * the array are OK however.
 * NB: caller should be running in econtext's per-tuple memory context.
 */
Datum
array_map(Datum arrayd,
    ExprState *exprstate, ExprContext *econtext,
    Oid retType, ArrayMapState *amstate)
{
 AnyArrayType *v = DatumGetAnyArrayP(arrayd);
 ArrayType  *result;
 Datum    *values;
 bool    *nulls;
 int     *dim;
 int   ndim;
 int   nitems;
 int   i;
 int32  nbytes = 0;
 int32  dataoffset;
 bool  hasnulls;
 Oid   inpType;
 int   inp_typlen;
 bool  inp_typbyval;
 char  inp_typalign;
 int   typlen;
 bool  typbyval;
 char  typalign;
 array_iter iter;
 ArrayMetaState *inp_extra;
 ArrayMetaState *ret_extra;
 Datum    *transform_source = exprstate->innermost_caseval;
 bool    *transform_source_isnull = exprstate->innermost_casenull;

 inpType = AARR_ELEMTYPE(v);
 ndim = AARR_NDIM(v);
 dim = AARR_DIMS(v);
 nitems = ArrayGetNItems(ndim, dim);

 /* Check for empty array */
 if (nitems <= 0)
 {
  /* Return empty array */
  return PointerGetDatum(construct_empty_array(retType));
 }

 /*
  * We arrange to look up info about input and return element types only
  * once per series of calls, assuming the element type doesn't change
  * underneath us.
 */
 inp_extra = &amstate->inp_extra;
 ret_extra = &amstate->ret_extra;

 if (inp_extra->element_type != inpType)
 {
  get_typlenbyvalalign(inpType,
        &inp_extra->typlen,
        &inp_extra->typbyval,
        &inp_extra->typalign);
  inp_extra->element_type = inpType;
 }
 inp_typlen = inp_extra->typlen;
 inp_typbyval = inp_extra->typbyval;
 inp_typalign = inp_extra->typalign;

 if (ret_extra->element_type != retType)
 {
  get_typlenbyvalalign(retType,
        &ret_extra->typlen,
        &ret_extra->typbyval,
        &ret_extra->typalign);
  ret_extra->element_type = retType;
 }
 typlen = ret_extra->typlen;
 typbyval = ret_extra->typbyval;
 typalign = ret_extra->typalign;

 /* Allocate temporary arrays for new values */
 values = (Datum *) palloc(nitems * sizeof(Datum));
 nulls = (bool *) palloc(nitems * sizeof(bool));

 /* Loop over source data */
 array_iter_setup(&iter, v);
 hasnulls = false;

 for (i = 0; i < nitems; i++)
 {
  /* Get source element, checking for NULL */
  *transform_source =
   array_iter_next(&iter, transform_source_isnull, i,
       inp_typlen, inp_typbyval, inp_typalign);

  /* Apply the given expression to source element */
  values[i] = ExecEvalExpr(exprstate, econtext, &nulls[i]);

  if (nulls[i])
   hasnulls = true;
  else
  {
   /* Ensure data is not toasted */
   if (typlen == -1)
    values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
   /* Update total result size */
   nbytes = att_addlength_datum(nbytes, typlen, values[i]);
   nbytes = att_align_nominal(nbytes, typalign);
   /* check for overflow of total request */
   if (!AllocSizeIsValid(nbytes))
    ereport(ERROR,
      (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
       errmsg("array size exceeds the maximum allowed (%d)",
        (int) MaxAllocSize)));
  }
 }

 /* Allocate and fill the result array */
 if (hasnulls)
 {
  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
  nbytes += dataoffset;
 }
 else
 {
  dataoffset = 0;   /* marker for no null bitmap */
  nbytes += ARR_OVERHEAD_NONULLS(ndim);
 }
 result = (ArrayType *) palloc0(nbytes);
 SET_VARSIZE(result, nbytes);
 result->ndim = ndim;
 result->dataoffset = dataoffset;
 result->elemtype = retType;
 memcpy(ARR_DIMS(result), AARR_DIMS(v), ndim * sizeof(int));
 memcpy(ARR_LBOUND(result), AARR_LBOUND(v), ndim * sizeof(int));

 CopyArrayEls(result,
     values, nulls, nitems,
     typlen, typbyval, typalign,
     false);

 /*
  * Note: do not risk trying to pfree the results of the called expression
 */
 pfree(values);
 pfree(nulls);

 return PointerGetDatum(result);
}

/*
 * construct_array --- simple method for constructing an array object
 *
 * elems: array of Datum items to become the array contents
 *    (NULL element values are not supported).
 * nelems: number of items
 * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
 *
 * A palloc'd 1-D array object is constructed and returned.  Note that
 * elem values will be copied into the object even if pass-by-ref type.
 * Also note the result will be 0-D not 1-D if nelems = 0.
 *
 * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
 * from the system catalogs, given the elmtype.  However, the caller is
 * in a better position to cache this info across multiple uses, or even
 * to hard-wire values if the element type is hard-wired.
 */
ArrayType *
construct_array(Datum *elems, int nelems,
    Oid elmtype,
    int elmlen, bool elmbyval, char elmalign)
{
 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);
}

/*
 * Like construct_array(), where elmtype must be a built-in type, and
 * elmlen/elmbyval/elmalign is looked up from hardcoded data.  This is often
 * useful when manipulating arrays from/for system catalogs.
 */
ArrayType *
construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
{
 int   elmlen;
 bool  elmbyval;
 char  elmalign;

 switch (elmtype)
 {
  case CHAROID:
   elmlen = 1;
   elmbyval = true;
   elmalign = TYPALIGN_CHAR;
   break;

  case CSTRINGOID:
   elmlen = -2;
   elmbyval = false;
   elmalign = TYPALIGN_CHAR;
   break;

  case FLOAT4OID:
   elmlen = sizeof(float4);
   elmbyval = true;
   elmalign = TYPALIGN_INT;
   break;

  case FLOAT8OID:
   elmlen = sizeof(float8);
   elmbyval = FLOAT8PASSBYVAL;
   elmalign = TYPALIGN_DOUBLE;
   break;

  case INT2OID:
   elmlen = sizeof(int16);
   elmbyval = true;
   elmalign = TYPALIGN_SHORT;
   break;

  case INT4OID:
   elmlen = sizeof(int32);
   elmbyval = true;
   elmalign = TYPALIGN_INT;
   break;

  case INT8OID:
   elmlen = sizeof(int64);
   elmbyval = FLOAT8PASSBYVAL;
   elmalign = TYPALIGN_DOUBLE;
   break;

  case NAMEOID:
   elmlen = NAMEDATALEN;
   elmbyval = false;
   elmalign = TYPALIGN_CHAR;
   break;

  case OIDOID:
  case REGTYPEOID:
   elmlen = sizeof(Oid);
   elmbyval = true;
   elmalign = TYPALIGN_INT;
   break;

  case TEXTOID:
   elmlen = -1;
   elmbyval = false;
   elmalign = TYPALIGN_INT;
   break;

  case TIDOID:
   elmlen = sizeof(ItemPointerData);
   elmbyval = false;
   elmalign = TYPALIGN_SHORT;
   break;

  case XIDOID:
   elmlen = sizeof(TransactionId);
   elmbyval = true;
   elmalign = TYPALIGN_INT;
   break;

  default:
   elog(ERROR, "type %u not supported by construct_array_builtin()", elmtype);
   /* keep compiler quiet */
   elmlen = 0;
   elmbyval = false;
   elmalign = 0;
 }

 return construct_array(elems, nelems, elmtype, elmlen, elmbyval, elmalign);
}

/*
 * construct_md_array --- simple method for constructing an array object
 *       with arbitrary dimensions and possible NULLs
 *
 * elems: array of Datum items to become the array contents
 * nulls: array of is-null flags (can be NULL if no nulls)
 * ndims: number of dimensions
 * dims: integer array with size of each dimension
 * lbs: integer array with lower bound of each dimension
 * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
 *
 * A palloc'd ndims-D array object is constructed and returned.  Note that
 * elem values will be copied into the object even if pass-by-ref type.
 * Also note the result will be 0-D not ndims-D if any dims[i] = 0.
 *
 * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
 * from the system catalogs, given the elmtype.  However, the caller is
 * in a better position to cache this info across multiple uses, or even
 * to hard-wire values if the element type is hard-wired.
 */
ArrayType *
construct_md_array(Datum *elems,
       bool *nulls,
       int ndims,
       int *dims,
       int *lbs,
       Oid elmtype, int elmlen, bool elmbyval, char elmalign)
{
 ArrayType  *result;
 bool  hasnulls;
 int32  nbytes;
 int32  dataoffset;
 int   i;
 int   nelems;

 if (ndims < 0)    /* we do allow zero-dimension arrays */
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     errmsg("invalid number of dimensions: %d", ndims)));
 if (ndims > MAXDIM)
  ereport(ERROR,
    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
      ndims, MAXDIM)));

 /* This checks for overflow of the array dimensions */
 nelems = ArrayGetNItems(ndims, dims);
 ArrayCheckBounds(ndims, dims, lbs);

 /* if ndims <= 0 or any dims[i] == 0, return empty array */
 if (nelems <= 0)
  return construct_empty_array(elmtype);

 /* compute required space */
 nbytes = 0;
 hasnulls = false;
 for (i = 0; i < nelems; i++)
 {
  if (nulls && nulls[i])
  {
   hasnulls = true;
   continue;
  }
  /* make sure data is not toasted */
  if (elmlen == -1)
   elems[i] = PointerGetDatum(PG_DETOAST_DATUM(elems[i]));
  nbytes = att_addlength_datum(nbytes, elmlen, elems[i]);
  nbytes = att_align_nominal(nbytes, elmalign);
  /* check for overflow of total request */
  if (!AllocSizeIsValid(nbytes))
   ereport(ERROR,
     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
      errmsg("array size exceeds the maximum allowed (%d)",
       (int) MaxAllocSize)));
 }

 /* Allocate and initialize result array */
 if (hasnulls)
 {
  dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nelems);
  nbytes += dataoffset;
 }
 else
 {
  dataoffset = 0;   /* marker for no null bitmap */
  nbytes += ARR_OVERHEAD_NONULLS(ndims);
 }
 result = (ArrayType *) palloc0(nbytes);
 SET_VARSIZE(result, nbytes);
 result->ndim = ndims;
 result->dataoffset = dataoffset;
 result->elemtype = elmtype;
 memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
 memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));

 CopyArrayEls(result,
     elems, nulls, nelems,
     elmlen, elmbyval, elmalign,
     false);

 return result;
}

/*
 * construct_empty_array --- make a zero-dimensional array of given type
 */
ArrayType *
construct_empty_array(Oid elmtype)
{
 ArrayType  *result;

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

/*
 * construct_empty_expanded_array: make an empty expanded array
 * given only type information.  (metacache can be NULL if not needed.)
 */
ExpandedArrayHeader *
construct_empty_expanded_array(Oid element_type,
          MemoryContext parentcontext,
          ArrayMetaState *metacache)
{
 ArrayType  *array = construct_empty_array(element_type);
 Datum  d;

 d = expand_array(PointerGetDatum(array), parentcontext, metacache);
 pfree(array);
 return (ExpandedArrayHeader *) DatumGetEOHP(d);
}

/*
 * deconstruct_array  --- simple method for extracting data from an array
 *
 * array: array object to examine (must not be NULL)
 * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
 * elemsp: return value, set to point to palloc'd array of Datum values
 * nullsp: return value, set to point to palloc'd array of isnull markers
 * nelemsp: return value, set to number of extracted values
 *
 * The caller may pass nullsp == NULL if it does not support NULLs in the
 * array.  Note that this produces a very uninformative error message,
 * so do it only in cases where a NULL is really not expected.
 *
 * If array elements are pass-by-ref data type, the returned Datums will
 * be pointers into the array object.
 *
 * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
 * from the system catalogs, given the elmtype.  However, the caller is
 * in a better position to cache this info across multiple uses, or even
 * to hard-wire values if the element type is hard-wired.
 */
void
deconstruct_array(ArrayType *array,
      Oid elmtype,
      int elmlen, bool elmbyval, char elmalign,
      Datum **elemsp, bool **nullsp, int *nelemsp)
{
 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;
   }
  }
 }
}

/*
 * Like deconstruct_array(), where elmtype must be a built-in type, and
 * elmlen/elmbyval/elmalign is looked up from hardcoded data.  This is often
 * useful when manipulating arrays from/for system catalogs.
 */
void
deconstruct_array_builtin(ArrayType *array,
        Oid elmtype,
        Datum **elemsp, bool **nullsp, int *nelemsp)
{
 int   elmlen;
 bool  elmbyval;
 char  elmalign;

 switch (elmtype)
 {
  case CHAROID:
   elmlen = 1;
   elmbyval = true;
   elmalign = TYPALIGN_CHAR;
   break;

  case CSTRINGOID:
   elmlen = -2;
   elmbyval = false;
   elmalign = TYPALIGN_CHAR;
   break;

  case FLOAT8OID:
   elmlen = sizeof(float8);
   elmbyval = FLOAT8PASSBYVAL;
   elmalign = TYPALIGN_DOUBLE;
   break;

  case INT2OID:
   elmlen = sizeof(int16);
   elmbyval = true;
   elmalign = TYPALIGN_SHORT;
   break;

  case INT4OID:
   elmlen = sizeof(int32);
   elmbyval = true;
   elmalign = TYPALIGN_INT;
   break;

  case OIDOID:
   elmlen = sizeof(Oid);
   elmbyval = true;
   elmalign = TYPALIGN_INT;
   break;

  case TEXTOID:
   elmlen = -1;
   elmbyval = false;
   elmalign = TYPALIGN_INT;
   break;

  case TIDOID:
   elmlen = sizeof(ItemPointerData);
   elmbyval = false;
   elmalign = TYPALIGN_SHORT;
   break;

  default:
   elog(ERROR, "type %u not supported by deconstruct_array_builtin()", elmtype);
   /* keep compiler quiet */
   elmlen = 0;
   elmbyval = false;
   elmalign = 0;
 }

 deconstruct_array(array, elmtype, elmlen, elmbyval, elmalign, elemsp, nullsp, nelemsp);
}

/*
 * array_contains_nulls --- detect whether an array has any null elements
 *
 * This gives an accurate answer, whereas testing ARR_HASNULL only tells
 * if the array *might* contain a null.
 */
bool
array_contains_nulls(ArrayType *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;
}


/*
 * array_eq :
 *    compares two arrays for equality
 * result :
 *    returns true if the arrays are equal, false otherwise.
 *
 * Note: we do not use array_cmp here, since equality may be meaningful in
 * datatypes that don't have a total ordering (and hence no btree support).
 */
Datum
array_eq(PG_FUNCTION_ARGS)
{
 LOCAL_FCINFO(locfcinfo, 2);
 AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
 AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
 Oid   collation = PG_GET_COLLATION();
 int   ndims1 = AARR_NDIM(array1);
 int   ndims2 = AARR_NDIM(array2);
 int     *dims1 = AARR_DIMS(array1);
 int     *dims2 = AARR_DIMS(array2);
 int     *lbs1 = AARR_LBOUND(array1);
 int     *lbs2 = AARR_LBOUND(array2);
 Oid   element_type = AARR_ELEMTYPE(array1);
 bool  result = true;
 int   nitems;
 TypeCacheEntry *typentry;
 int   typlen;
 bool  typbyval;
 char  typalign;
 array_iter it1;
 array_iter it2;
 int   i;

 if (element_type != AARR_ELEMTYPE(array2))
  ereport(ERROR,
    (errcode(ERRCODE_DATATYPE_MISMATCH),
     errmsg("cannot compare arrays of different element types")));

 /* fast path if the arrays do not have the same dimensionality */
 if (ndims1 != ndims2 ||
  memcmp(dims1, dims2, ndims1 * sizeof(int)) != 0 ||
  memcmp(lbs1, lbs2, ndims1 * sizeof(int)) != 0)
  result = false;
 else
 {
  /*
   * We arrange to look up the equality function only once per series of
   * calls, assuming the element type doesn't change underneath us.  The
   * typcache is used so that we have no memory leakage when being used
   * as an index support function.
 */
  typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
  if (typentry == NULL ||
   typentry->type_id != element_type)
  {
   typentry = lookup_type_cache(element_type,
           TYPECACHE_EQ_OPR_FINFO);
   if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
    ereport(ERROR,
      (errcode(ERRCODE_UNDEFINED_FUNCTION),
       errmsg("could not identify an equality operator for type %s",
        format_type_be(element_type))));
   fcinfo->flinfo->fn_extra = typentry;
  }
  typlen = typentry->typlen;
  typbyval = typentry->typbyval;
  typalign = typentry->typalign;

  /*
   * apply the operator to each pair of array elements.
 */
  InitFunctionCallInfoData(*locfcinfo, &typentry->eq_opr_finfo, 2,
         collation, NULL, NULL);

  /* Loop over source data */
  nitems = ArrayGetNItems(ndims1, dims1);
  array_iter_setup(&it1, array1);
  array_iter_setup(&it2, array2);

  for (i = 0; i < nitems; i++)
  {
   Datum  elt1;
   Datum  elt2;
   bool  isnull1;
   bool  isnull2;
   bool  oprresult;

   /* Get elements, checking for NULL */
   elt1 = array_iter_next(&it1, &isnull1, i,
           typlen, typbyval, typalign);
   elt2 = array_iter_next(&it2, &isnull2, i,
           typlen, typbyval, typalign);

   /*
    * We consider two NULLs equal; NULL and not-NULL are unequal.
 */
   if (isnull1 && isnull2)
    continue;
   if (isnull1 || isnull2)
   {
    result = false;
    break;
   }

   /*
    * Apply the operator to the element pair; treat NULL as false
 */
   locfcinfo->args[0].value = elt1;
   locfcinfo->args[0].isnull = false;
   locfcinfo->args[1].value = elt2;
   locfcinfo->args[1].isnull = false;
   locfcinfo->isnull = false;
   oprresult = DatumGetBool(FunctionCallInvoke(locfcinfo));
   if (locfcinfo->isnull || !oprresult)
   {
    result = false;
    break;
   }
  }
 }

 /* Avoid leaking memory when handed toasted input. */
 AARR_FREE_IF_COPY(array1, 0);
 AARR_FREE_IF_COPY(array2, 1);

 PG_RETURN_BOOL(result);
}


/*-----------------------------------------------------------------------------
 * array-array bool operators:
 *  Given two arrays, iterate comparison operators
 *  over the array. Uses logic similar to text comparison
 *  functions, except element-by-element instead of
 *  character-by-character.
 *----------------------------------------------------------------------------
 */

Datum
array_ne(PG_FUNCTION_ARGS)
{
 PG_RETURN_BOOL(!DatumGetBool(array_eq(fcinfo)));
}

Datum
array_lt(PG_FUNCTION_ARGS)
{
 PG_RETURN_BOOL(array_cmp(fcinfo) < 0);
}

Datum
array_gt(PG_FUNCTION_ARGS)
{
 PG_RETURN_BOOL(array_cmp(fcinfo) > 0);
}

Datum
array_le(PG_FUNCTION_ARGS)
{
 PG_RETURN_BOOL(array_cmp(fcinfo) <= 0);
}

Datum
array_ge(PG_FUNCTION_ARGS)
{
 PG_RETURN_BOOL(array_cmp(fcinfo) >= 0);
}

Datum
btarraycmp(PG_FUNCTION_ARGS)
{
 PG_RETURN_INT32(array_cmp(fcinfo));
}

/*
 * array_cmp()
 * Internal comparison function for arrays.
 *
 * Returns -1, 0 or 1
 */
static int
array_cmp(FunctionCallInfo fcinfo)
{
 LOCAL_FCINFO(locfcinfo, 2);
 AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
 AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
 Oid   collation = PG_GET_COLLATION();
 int   ndims1 = AARR_NDIM(array1);
 int   ndims2 = AARR_NDIM(array2);
 int     *dims1 = AARR_DIMS(array1);
 int     *dims2 = AARR_DIMS(array2);
 int   nitems1 = ArrayGetNItems(ndims1, dims1);
 int   nitems2 = ArrayGetNItems(ndims2, dims2);
 Oid   element_type = AARR_ELEMTYPE(array1);
 int   result = 0;
 TypeCacheEntry *typentry;
 int   typlen;
 bool  typbyval;
 char  typalign;
 int   min_nitems;
 array_iter it1;
 array_iter it2;
 int   i;

 if (element_type != AARR_ELEMTYPE(array2))
  ereport(ERROR,
    (errcode(ERRCODE_DATATYPE_MISMATCH),
     errmsg("cannot compare arrays of different element types")));

 /*
  * We arrange to look up the comparison function only once per series of
  * calls, assuming the element type doesn't change underneath us. The
  * typcache is used so that we have no memory leakage when being used as
  * an index support function.
 */
 typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
 if (typentry == NULL ||
  typentry->type_id != element_type)
 {
  typentry = lookup_type_cache(element_type,
          TYPECACHE_CMP_PROC_FINFO);
  if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
   ereport(ERROR,
     (errcode(ERRCODE_UNDEFINED_FUNCTION),
      errmsg("could not identify a comparison function for type %s",
       format_type_be(element_type))));
  fcinfo->flinfo->fn_extra = typentry;
 }
 typlen = typentry->typlen;
 typbyval = typentry->typbyval;
 typalign = typentry->typalign;

 /*
  * apply the operator to each pair of array elements.
 */
 InitFunctionCallInfoData(*locfcinfo, &typentry->cmp_proc_finfo, 2,
        collation, NULL, NULL);

 /* Loop over source data */
 min_nitems = Min(nitems1, nitems2);
 array_iter_setup(&it1, array1);
 array_iter_setup(&it2, array2);

 for (i = 0; i < min_nitems; i++)
 {
  Datum  elt1;
  Datum  elt2;
  bool  isnull1;
  bool  isnull2;
  int32  cmpresult;

  /* Get elements, checking for NULL */
  elt1 = array_iter_next(&it1, &isnull1, i, typlen, typbyval, typalign);
  elt2 = array_iter_next(&it2, &isnull2, i, typlen, typbyval, typalign);

  /*
   * We consider two NULLs equal; NULL > not-NULL.
 */
  if (isnull1 && isnull2)
   continue;
  if (isnull1)
  {
   /* arg1 is greater than arg2 */
   result = 1;
   break;
  }
  if (isnull2)
  {
   /* arg1 is less than arg2 */
   result = -1;
   break;
  }

  /* Compare the pair of elements */
  locfcinfo->args[0].value = elt1;
  locfcinfo->args[0].isnull = false;
  locfcinfo->args[1].value = elt2;
  locfcinfo->args[1].isnull = false;
  cmpresult = DatumGetInt32(FunctionCallInvoke(locfcinfo));

  /* We don't expect comparison support functions to return null */
  Assert(!locfcinfo->isnull);

  if (cmpresult == 0)
   continue;   /* equal */

  if (cmpresult < 0)
  {
   /* arg1 is less than arg2 */
   result = -1;
   break;
  }
  else
  {
   /* arg1 is greater than arg2 */
   result = 1;
   break;
  }
 }

 /*
  * If arrays contain same data (up to end of shorter one), apply
  * additional rules to sort by dimensionality.  The relative significance
  * of the different bits of information is historical; mainly we just care
  * that we don't say "equal" for arrays of different dimensionality.
 */
 if (result == 0)
 {
  if (nitems1 != nitems2)
   result = (nitems1 < nitems2) ? -1 : 1;
  else if (ndims1 != ndims2)
   result = (ndims1 < ndims2) ? -1 : 1;
  else
  {
   for (i = 0; i < ndims1; i++)
   {
    if (dims1[i] != dims2[i])
    {
     result = (dims1[i] < dims2[i]) ? -1 : 1;
     break;
    }
   }
   if (result == 0)
   {
    int     *lbound1 = AARR_LBOUND(array1);
    int     *lbound2 = AARR_LBOUND(array2);

    for (i = 0; i < ndims1; i++)
    {
     if (lbound1[i] != lbound2[i])
     {
      result = (lbound1[i] < lbound2[i]) ? -1 : 1;
      break;
     }
    }
   }
  }
 }

 /* Avoid leaking memory when handed toasted input. */
 AARR_FREE_IF_COPY(array1, 0);
 AARR_FREE_IF_COPY(array2, 1);

 return result;
}


/*-----------------------------------------------------------------------------
 * array hashing
 *  Hash the elements and combine the results.
 *----------------------------------------------------------------------------
 */

Datum
hash_array(PG_FUNCTION_ARGS)
{
 LOCAL_FCINFO(locfcinfo, 1);
 AnyArrayType *array = PG_GETARG_ANY_ARRAY_P(0);
 int   ndims = AARR_NDIM(array);
 int     *dims = AARR_DIMS(array);
 Oid   element_type = AARR_ELEMTYPE(array);
 uint32  result = 1;
 int   nitems;
 TypeCacheEntry *typentry;
 int   typlen;
 bool  typbyval;
 char  typalign;
 int   i;
 array_iter iter;

 /*
  * We arrange to look up the hash function only once per series of calls,
  * assuming the element type doesn't change underneath us.  The typcache
  * is used so that we have no memory leakage when being used as an index
  * support function.
 */
 typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
 if (typentry == NULL ||
  typentry->type_id != element_type)
 {
  typentry = lookup_type_cache(element_type,
          TYPECACHE_HASH_PROC_FINFO);
  if (!OidIsValid(typentry->hash_proc_finfo.fn_oid) && element_type != RECORDOID)
   ereport(ERROR,
     (errcode(ERRCODE_UNDEFINED_FUNCTION),
      errmsg("could not identify a hash function for type %s",
       format_type_be(element_type))));

  /*
   * The type cache doesn't believe that record is hashable (see
   * cache_record_field_properties()), but since we're here, we're
   * committed to hashing, so we can assume it does.  Worst case, if any
   * components of the record don't support hashing, we will fail at
   * execution.
 */
  if (element_type == RECORDOID)
  {
   MemoryContext oldcontext;
   TypeCacheEntry *record_typentry;

   oldcontext = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);

   /*
    * Make fake type cache entry structure.  Note that we can't just
    * modify typentry, since that points directly into the type
    * cache.
 */
   record_typentry = palloc0(sizeof(*record_typentry));
   record_typentry->type_id = element_type;

   /* fill in what we need below */
   record_typentry->typlen = typentry->typlen;
   record_typentry->typbyval = typentry->typbyval;
   record_typentry->typalign = typentry->typalign;
   fmgr_info(F_HASH_RECORD, &record_typentry->hash_proc_finfo);

   MemoryContextSwitchTo(oldcontext);

   typentry = record_typentry;
  }

  fcinfo->flinfo->fn_extra = typentry;
 }

 typlen = typentry->typlen;
 typbyval = typentry->typbyval;
 typalign = typentry->typalign;

 /*
  * apply the hash function to each array element.
 */
 InitFunctionCallInfoData(*locfcinfo, &typentry->hash_proc_finfo, 1,
        PG_GET_COLLATION(), NULL, NULL);

 /* Loop over source data */
 nitems = ArrayGetNItems(ndims, dims);
 array_iter_setup(&iter, array);

 for (i = 0; i < nitems; i++)
 {
  Datum  elt;
  bool  isnull;
  uint32  elthash;

  /* Get element, checking for NULL */
  elt = array_iter_next(&iter, &isnull, i, typlen, typbyval, typalign);

  if (isnull)
  {
   /* Treat nulls as having hashvalue 0 */
   elthash = 0;
  }
  else
  {
   /* Apply the hash function */
   locfcinfo->args[0].value = elt;
   locfcinfo->args[0].isnull = false;
   elthash = DatumGetUInt32(FunctionCallInvoke(locfcinfo));
   /* We don't expect hash functions to return null */
   Assert(!locfcinfo->isnull);
  }

  /*
   * Combine hash values of successive elements by multiplying the
   * current value by 31 and adding on the new element's hash value.
   *
   * The result is a sum in which each element's hash value is
   * multiplied by a different power of 31. This is modulo 2^32
   * arithmetic, and the powers of 31 modulo 2^32 form a cyclic group of
   * order 2^27. So for arrays of up to 2^27 elements, each element's
   * hash value is multiplied by a different (odd) number, resulting in
   * a good mixing of all the elements' hash values.
 */
  result = (result << 5) - result + elthash;
 }

 /* Avoid leaking memory when handed toasted input. */
 AARR_FREE_IF_COPY(array, 0);

 PG_RETURN_UINT32(result);
}

/*
 * Returns 64-bit value by hashing a value to a 64-bit value, with a seed.
 * Otherwise, similar to hash_array.
 */
Datum
hash_array_extended(PG_FUNCTION_ARGS)
{
 LOCAL_FCINFO(locfcinfo, 2);
 AnyArrayType *array = PG_GETARG_ANY_ARRAY_P(0);
 uint64  seed = PG_GETARG_INT64(1);
 int   ndims = AARR_NDIM(array);
 int     *dims = AARR_DIMS(array);
 Oid   element_type = AARR_ELEMTYPE(array);
 uint64  result = 1;
 int   nitems;
 TypeCacheEntry *typentry;
 int   typlen;
 bool  typbyval;
 char  typalign;
 int   i;
 array_iter iter;

 typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
 if (typentry == NULL ||
  typentry->type_id != element_type)
 {
  typentry = lookup_type_cache(element_type,
          TYPECACHE_HASH_EXTENDED_PROC_FINFO);
  if (!OidIsValid(typentry->hash_extended_proc_finfo.fn_oid))
   ereport(ERROR,
     (errcode(ERRCODE_UNDEFINED_FUNCTION),
      errmsg("could not identify an extended hash function for type %s",
       format_type_be(element_type))));
  fcinfo->flinfo->fn_extra = typentry;
 }
 typlen = typentry->typlen;
 typbyval = typentry->typbyval;
 typalign = typentry->typalign;

 InitFunctionCallInfoData(*locfcinfo, &typentry->hash_extended_proc_finfo, 2,
        PG_GET_COLLATION(), NULL, NULL);

 /* Loop over source data */
 nitems = ArrayGetNItems(ndims, dims);
 array_iter_setup(&iter, array);

 for (i = 0; i < nitems; i++)
 {
  Datum  elt;
  bool  isnull;
  uint64  elthash;

  /* Get element, checking for NULL */
  elt = array_iter_next(&iter, &isnull, i, typlen, typbyval, typalign);

  if (isnull)
  {
   elthash = 0;
  }
  else
  {
   /* Apply the hash function */
   locfcinfo->args[0].value = elt;
   locfcinfo->args[0].isnull = false;
   locfcinfo->args[1].value = Int64GetDatum(seed);
   locfcinfo->args[1].isnull = false;
   elthash = DatumGetUInt64(FunctionCallInvoke(locfcinfo));
   /* We don't expect hash functions to return null */
   Assert(!locfcinfo->isnull);
  }

  result = (result << 5) - result + elthash;
 }

 AARR_FREE_IF_COPY(array, 0);

 PG_RETURN_UINT64(result);
}


/*-----------------------------------------------------------------------------
 * array overlap/containment comparisons
 *  These use the same methods of comparing array elements as array_eq.
 *  We consider only the elements of the arrays, ignoring dimensionality.
 *----------------------------------------------------------------------------
 */

/*
 * array_contain_compare :
 *    compares two arrays for overlap/containment
 *
 * When matchall is true, return true if all members of array1 are in array2.
 * When matchall is false, return true if any members of array1 are in array2.
 */
static bool
array_contain_compare(AnyArrayType *array1, AnyArrayType *array2, Oid collation,
       bool matchall, void **fn_extra)
{
 LOCAL_FCINFO(locfcinfo, 2);
 bool  result = matchall;
 Oid   element_type = AARR_ELEMTYPE(array1);
 TypeCacheEntry *typentry;
 int   nelems1;
 Datum    *values2;
 bool    *nulls2;
 int   nelems2;
 int   typlen;
 bool  typbyval;
 char  typalign;
 int   i;
 int   j;
 array_iter it1;

 if (element_type != AARR_ELEMTYPE(array2))
  ereport(ERROR,
    (errcode(ERRCODE_DATATYPE_MISMATCH),
     errmsg("cannot compare arrays of different element types")));

 /*
  * We arrange to look up the equality function only once per series of
  * calls, assuming the element type doesn't change underneath us.  The
  * typcache is used so that we have no memory leakage when being used as
  * an index support function.
 */
 typentry = (TypeCacheEntry *) *fn_extra;
 if (typentry == NULL ||
  typentry->type_id != element_type)
 {
  typentry = lookup_type_cache(element_type,
          TYPECACHE_EQ_OPR_FINFO);
  if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
   ereport(ERROR,
     (errcode(ERRCODE_UNDEFINED_FUNCTION),
      errmsg("could not identify an equality operator for type %s",
       format_type_be(element_type))));
  *fn_extra = typentry;
 }
 typlen = typentry->typlen;
 typbyval = typentry->typbyval;
 typalign = typentry->typalign;

 /*
  * Since we probably will need to scan array2 multiple times, it's
  * worthwhile to use deconstruct_array on it.  We scan array1 the hard way
  * however, since we very likely won't need to look at all of it.
 */
 if (VARATT_IS_EXPANDED_HEADER(array2))
 {
  /* This should be safe even if input is read-only */
  deconstruct_expanded_array(&(array2->xpn));
  values2 = array2->xpn.dvalues;
  nulls2 = array2->xpn.dnulls;
  nelems2 = array2->xpn.nelems;
 }
 else
  deconstruct_array((ArrayType *) array2,
        element_type, typlen, typbyval, typalign,
        &values2, &nulls2, &nelems2);

 /*
  * Apply the comparison operator to each pair of array elements.
 */
 InitFunctionCallInfoData(*locfcinfo, &typentry->eq_opr_finfo, 2,
        collation, NULL, NULL);

 /* Loop over source data */
 nelems1 = ArrayGetNItems(AARR_NDIM(array1), AARR_DIMS(array1));
 array_iter_setup(&it1, array1);

 for (i = 0; i < nelems1; i++)
 {
  Datum  elt1;
  bool  isnull1;

  /* Get element, checking for NULL */
  elt1 = array_iter_next(&it1, &isnull1, i, typlen, typbyval, typalign);

  /*
   * We assume that the comparison operator is strict, so a NULL can't
   * match anything.  XXX this diverges from the "NULL=NULL" behavior of
   * array_eq, should we act like that?
 */
  if (isnull1)
  {
   if (matchall)
   {
    result = false;
    break;
   }
   continue;
  }

  for (j = 0; j < nelems2; j++)
  {
   Datum  elt2 = values2[j];
   bool  isnull2 = nulls2 ? nulls2[j] : false;
   bool  oprresult;

   if (isnull2)
    continue;  /* can't match */

   /*
    * Apply the operator to the element pair; treat NULL as false
 */
   locfcinfo->args[0].value = elt1;
   locfcinfo->args[0].isnull = false;
   locfcinfo->args[1].value = elt2;
   locfcinfo->args[1].isnull = false;
   locfcinfo->isnull = false;
   oprresult = DatumGetBool(FunctionCallInvoke(locfcinfo));
   if (!locfcinfo->isnull && oprresult)
    break;
  }

  if (j < nelems2)
  {
   /* found a match for elt1 */
   if (!matchall)
   {
    result = true;
    break;
   }
  }
  else
  {
   /* no match for elt1 */
   if (matchall)
   {
    result = false;
    break;
   }
  }
 }

 return result;
}

Datum
arrayoverlap(PG_FUNCTION_ARGS)
{
 AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
 AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
 Oid   collation = PG_GET_COLLATION();
 bool  result;

 result = array_contain_compare(array1, array2, collation, false,
           &fcinfo->flinfo->fn_extra);

 /* Avoid leaking memory when handed toasted input. */
 AARR_FREE_IF_COPY(array1, 0);
 AARR_FREE_IF_COPY(array2, 1);

 PG_RETURN_BOOL(result);
}

Datum
arraycontains(PG_FUNCTION_ARGS)
{
 AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
 AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
 Oid   collation = PG_GET_COLLATION();
 bool  result;

 result = array_contain_compare(array2, array1, collation, true,
           &fcinfo->flinfo->fn_extra);

 /* Avoid leaking memory when handed toasted input. */
 AARR_FREE_IF_COPY(array1, 0);
 AARR_FREE_IF_COPY(array2, 1);

 PG_RETURN_BOOL(result);
}

Datum
arraycontained(PG_FUNCTION_ARGS)
{
 AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
 AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
 Oid   collation = PG_GET_COLLATION();
 bool  result;

 result = array_contain_compare(array1, array2, collation, true,
           &fcinfo->flinfo->fn_extra);

 /* Avoid leaking memory when handed toasted input. */
 AARR_FREE_IF_COPY(array1, 0);
 AARR_FREE_IF_COPY(array2, 1);

 PG_RETURN_BOOL(result);
}


/*-----------------------------------------------------------------------------
 * Array iteration functions
 *  These functions are used to iterate efficiently through arrays
 *-----------------------------------------------------------------------------
 */

/*
 * array_create_iterator --- set up to iterate through an array
 *
 * If slice_ndim is zero, we will iterate element-by-element; the returned
 * datums are of the array's element type.
 *
 * If slice_ndim is 1..ARR_NDIM(arr), we will iterate by slices: the
 * returned datums are of the same array type as 'arr', but of size
 * equal to the rightmost N dimensions of 'arr'.
 *
 * The passed-in array must remain valid for the lifetime of the iterator.
 */
ArrayIterator
array_create_iterator(ArrayType *arr, int slice_ndim, ArrayMetaState *mstate)
{
 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;
}

/*
 * Iterate through the array referenced by 'iterator'.
 *
 * As long as there is another element (or slice), return it into
 * *value / *isnull, and return true.  Return false when no more data.
 */
bool
array_iterate(ArrayIterator iterator, Datum *value, bool *isnull)
{
 /* 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;
}

/*
 * Release an ArrayIterator data structure
 */
void
array_free_iterator(ArrayIterator iterator)
{
 if (iterator->slice_ndim > 0)
 {
  pfree(iterator->slice_values);
  pfree(iterator->slice_nulls);
 }
 pfree(iterator);
}


/***************************************************************************/
/******************|   Support  Routines   |*****************/
/***************************************************************************/

/*
 * Check whether a specific array element is NULL
 *
 * nullbitmap: pointer to array's null bitmap (NULL if none)
 * offset: 0-based linear element number of array element
 */
static bool
array_get_isnull(const bits8 *nullbitmap, int offset)
{
 if (nullbitmap == NULL)
  return false;   /* assume not null */
 if (nullbitmap[offset / 8] & (1 << (offset % 8)))
  return false;   /* not null */
 return true;
}

/*
 * Set a specific array element's null-bitmap entry
 *
 * nullbitmap: pointer to array's null bitmap (mustn't be NULL)
 * offset: 0-based linear element number of array element
 * isNull: null status to set
 */
static void
array_set_isnull(bits8 *nullbitmap, int offset, bool isNull)
{
 int   bitmask;

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

/*
 * Fetch array element at pointer, converted correctly to a Datum
 *
 * Caller must have handled case of NULL element
 */
static Datum
ArrayCast(char *value, bool byval, int len)
{
 return fetch_att(value, byval, len);
}

/*
 * Copy datum to *dest and return total space used (including align padding)
 *
 * Caller must have handled case of NULL element
 */
static int
ArrayCastAndSet(Datum src,
    int typlen,
    bool typbyval,
    char typalign,
    char *dest)
{
 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;
}

/*
 * Advance ptr over nitems array elements
 *
 * ptr: starting location in array
 * offset: 0-based linear element number of first element (the one at *ptr)
 * nullbitmap: start of array's null bitmap, or NULL if none
 * nitems: number of array elements to advance over (>= 0)
 * typlen, typbyval, typalign: storage parameters of array element datatype
 *
 * It is caller's responsibility to ensure that nitems is within range
 */
static char *
array_seek(char *ptr, int offset, bits8 *nullbitmap, int nitems,
     int typlen, bool typbyval, char typalign)
{
 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;
}

/*
 * Compute total size of the nitems array elements starting at *ptr
 *
 * Parameters same as for array_seek
 */
static int
array_nelems_size(char *ptr, int offset, bits8 *nullbitmap, int nitems,
      int typlen, bool typbyval, char typalign)
{
 return array_seek(ptr, offset, nullbitmap, nitems,
       typlen, typbyval, typalign) - ptr;
}

/*
 * Copy nitems array elements from srcptr to destptr
 *
 * destptr: starting destination location (must be enough room!)
 * nitems: number of array elements to copy (>= 0)
 * srcptr: starting location in source array
 * offset: 0-based linear element number of first element (the one at *srcptr)
 * nullbitmap: start of source array's null bitmap, or NULL if none
 * typlen, typbyval, typalign: storage parameters of array element datatype
 *
 * Returns number of bytes copied
 *
 * NB: this does not take care of setting up the destination's null bitmap!
 */
static int
array_copy(char *destptr, int nitems,
     char *srcptr, int offset, bits8 *nullbitmap,
     int typlen, bool typbyval, char typalign)
{
 int   numbytes;

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

/*
 * Copy nitems null-bitmap bits from source to destination
 *
 * destbitmap: start of destination array's null bitmap (mustn't be NULL)
 * destoffset: 0-based linear element number of first dest element
 * srcbitmap: start of source array's null bitmap, or NULL if none
 * srcoffset: 0-based linear element number of first source element
 * nitems: number of bits to copy (>= 0)
 *
 * If srcbitmap is NULL then we assume the source is all-non-NULL and
 * fill 1's into the destination bitmap.  Note that only the specified
 * bits in the destination map are changed, not any before or after.
 *
 * Note: this could certainly be optimized using standard bitblt methods.
 * However, it's not clear that the typical Postgres array has enough elements
 * to make it worth worrying too much.  For the moment, KISS.
 */
void
array_bitmap_copy(bits8 *destbitmap, int destoffset,
      const bits8 *srcbitmap, int srcoffset,
      int nitems)
{
 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;
 }
}

/*
 * Compute space needed for a slice of an array
 *
 * We assume the caller has verified that the slice coordinates are valid.
 */
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)
{
 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;
}

/*
 * Extract a slice of an array into consecutive elements in the destination
 * array.
 *
 * We assume the caller has verified that the slice coordinates are valid,
 * allocated enough storage for the result, and initialized the header
 * of the new array.
 */
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)
{
 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);
}

/*
 * Insert a slice into an array.
 *
 * ndim/dim[]/lb[] are dimensions of the original array.  A new array with
 * those same dimensions is to be constructed.  destArray must already
 * have been allocated and its header initialized.
 *
 * st[]/endp[] identify the slice to be replaced.  Elements within the slice
 * volume are taken from consecutive elements of the srcArray; elements
 * outside it are copied from origArray.
 *
 * We assume the caller has verified that the slice coordinates are valid.
 */
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)
{
 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);
}

/*
 * initArrayResult - initialize an empty ArrayBuildState
 *
 * element_type is the array element type (must be a valid array element type)
 * rcontext is where to keep working state
 * subcontext is a flag determining whether to use a separate memory context
 *
 * Note: there are two common schemes for using accumArrayResult().
 * In the older scheme, you start with a NULL ArrayBuildState pointer, and
 * call accumArrayResult once per element.  In this scheme you end up with
 * a NULL pointer if there were no elements, which you need to special-case.
 * In the newer scheme, call initArrayResult and then call accumArrayResult
 * once per element.  In this scheme you always end with a non-NULL pointer
 * that you can pass to makeArrayResult; you get an empty array if there
 * were no elements.  This is preferred if an empty array is what you want.
 *
 * It's possible to choose whether to create a separate memory context for the
 * array build state, or whether to allocate it directly within rcontext.
 *
 * When there are many concurrent small states (e.g. array_agg() using hash
 * aggregation of many small groups), using a separate memory context for each
 * one may result in severe memory bloat. In such cases, use the same memory
 * context to initialize all such array build states, and pass
 * subcontext=false.
 *
 * In cases when the array build states have different lifetimes, using a
 * single memory context is impractical. Instead, pass subcontext=true so that
 * the array build states can be freed individually.
 */
ArrayBuildState *
initArrayResult(Oid element_type, MemoryContext rcontext, bool subcontext)
{
 /*
  * When using a subcontext, we can afford to start with a somewhat larger
  * initial array size.  Without subcontexts, we'd better hope that most of
  * the states stay small ...
 */
 return initArrayResultWithSize(element_type, rcontext, subcontext,
           subcontext ? 64 : 8);
}

/*
 * initArrayResultWithSize
 *  As initArrayResult, but allow the initial size of the allocated arrays
 *  to be specified.
 */
ArrayBuildState *
initArrayResultWithSize(Oid element_type, MemoryContext rcontext,
      bool subcontext, int initsize)
{
 ArrayBuildState *astate;
 MemoryContext arr_context = rcontext;

 /* Make a temporary context to hold all the junk */
 if (subcontext)
  arr_context = AllocSetContextCreate(rcontext,
           "accumArrayResult",
           ALLOCSET_DEFAULT_SIZES);

 astate = (ArrayBuildState *)
  MemoryContextAlloc(arr_context, sizeof(ArrayBuildState));
 astate->mcontext = arr_context;
 astate->private_cxt = subcontext;
 astate->alen = initsize;
 astate->dvalues = (Datum *)
  MemoryContextAlloc(arr_context, astate->alen * sizeof(Datum));
 astate->dnulls = (bool *)
  MemoryContextAlloc(arr_context, astate->alen * sizeof(bool));
 astate->nelems = 0;
 astate->element_type = element_type;
 get_typlenbyvalalign(element_type,
       &astate->typlen,
       &astate->typbyval,
       &astate->typalign);

 return astate;
}

/*
 * accumArrayResult - accumulate one (more) Datum for an array result
 *
 * astate is working state (can be NULL on first call)
 * dvalue/disnull represent the new Datum to append to the array
 * element_type is the Datum's type (must be a valid array element type)
 * rcontext is where to keep working state
 */
ArrayBuildState *
accumArrayResult(ArrayBuildState *astate,
     Datum dvalue, bool disnull,
     Oid element_type,
     MemoryContext rcontext)
{
 MemoryContext oldcontext;

 if (astate == NULL)
 {
  /* First time through --- initialize */
  astate = initArrayResult(element_type, rcontext, true);
 }
 else
 {
  Assert(astate->element_type == element_type);
 }

 oldcontext = MemoryContextSwitchTo(astate->mcontext);

 /* enlarge dvalues[]/dnulls[] if needed */
 if (astate->nelems >= astate->alen)
 {
  astate->alen *= 2;
  /* give an array-related error if we go past MaxAllocSize */
  if (!AllocSizeIsValid(astate->alen * sizeof(Datum)))
   ereport(ERROR,
     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
      errmsg("array size exceeds the maximum allowed (%d)",
       (int) MaxAllocSize)));
  astate->dvalues = (Datum *)
   repalloc(astate->dvalues, astate->alen * sizeof(Datum));
  astate->dnulls = (bool *)
   repalloc(astate->dnulls, astate->alen * sizeof(bool));
 }

 /*
  * Ensure pass-by-ref stuff is copied into mcontext; and detoast it too if
  * it's varlena.  (You might think that detoasting is not needed here
  * because construct_md_array can detoast the array elements later.
  * However, we must not let construct_md_array modify the ArrayBuildState
  * because that would mean array_agg_finalfn damages its input, which is
  * verboten.  Also, this way frequently saves one copying step.)
 */
 if (!disnull && !astate->typbyval)
 {
  if (astate->typlen == -1)
   dvalue = PointerGetDatum(PG_DETOAST_DATUM_COPY(dvalue));
  else
   dvalue = datumCopy(dvalue, astate->typbyval, astate->typlen);
 }

 astate->dvalues[astate->nelems] = dvalue;
 astate->dnulls[astate->nelems] = disnull;
 astate->nelems++;

 MemoryContextSwitchTo(oldcontext);

 return astate;
}

/*
 * makeArrayResult - produce 1-D final result of accumArrayResult
 *
 * Note: only releases astate if it was initialized within a separate memory
 * context (i.e. using subcontext=true when calling initArrayResult).
 *
 * astate is working state (must not be NULL)
 * rcontext is where to construct result
 */
Datum
makeArrayResult(ArrayBuildState *astate,
    MemoryContext rcontext)
{
 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);
}

/*
 * makeMdArrayResult - produce multi-D final result of accumArrayResult
 *
 * beware: no check that specified dimensions match the number of values
 * accumulated.
 *
 * Note: if the astate was not initialized within a separate memory context
 * (that is, initArrayResult was called with subcontext=false), then using
 * release=true is illegal. Instead, release astate along with the rest of its
 * context when appropriate.
 *
 * astate is working state (must not be NULL)
 * rcontext is where to construct result
 * release is true if okay to release working state
 */
Datum
makeMdArrayResult(ArrayBuildState *astate,
      int ndims,
      int *dims,
      int *lbs,
      MemoryContext rcontext,
      bool release)
{
 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);
}

/*
 * The following three functions provide essentially the same API as
 * initArrayResult/accumArrayResult/makeArrayResult, but instead of accepting
 * inputs that are array elements, they accept inputs that are arrays and
 * produce an output array having N+1 dimensions.  The inputs must all have
 * identical dimensionality as well as element type.
 */

/*
 * initArrayResultArr - initialize an empty ArrayBuildStateArr
 *
 * array_type is the array type (must be a valid varlena array type)
 * element_type is the type of the array's elements (lookup if InvalidOid)
 * rcontext is where to keep working state
 * subcontext is a flag determining whether to use a separate memory context
 */
ArrayBuildStateArr *
initArrayResultArr(Oid array_type, Oid element_type, MemoryContext rcontext,
       bool subcontext)
{
 ArrayBuildStateArr *astate;
 MemoryContext arr_context = rcontext; /* by default use the parent ctx */

 /* Lookup element type, unless element_type already provided */
 if (!OidIsValid(element_type))
 {
  element_type = get_element_type(array_type);

  if (!OidIsValid(element_type))
   ereport(ERROR,
     (errcode(ERRCODE_DATATYPE_MISMATCH),
      errmsg("data type %s is not an array type",
       format_type_be(array_type))));
 }

 /* Make a temporary context to hold all the junk */
 if (subcontext)
  arr_context = AllocSetContextCreate(rcontext,
           "accumArrayResultArr",
           ALLOCSET_DEFAULT_SIZES);

 /* Note we initialize all fields to zero */
 astate = (ArrayBuildStateArr *)
  MemoryContextAllocZero(arr_context, sizeof(ArrayBuildStateArr));
 astate->mcontext = arr_context;
 astate->private_cxt = subcontext;

 /* Save relevant datatype information */
 astate->array_type = array_type;
 astate->element_type = element_type;

 return astate;
}

/*
 * accumArrayResultArr - accumulate one (more) sub-array for an array result
 *
 * astate is working state (can be NULL on first call)
 * dvalue/disnull represent the new sub-array to append to the array
 * array_type is the array type (must be a valid varlena array type)
 * rcontext is where to keep working state
 */
ArrayBuildStateArr *
accumArrayResultArr(ArrayBuildStateArr *astate,
     Datum dvalue, bool disnull,
     Oid array_type,
     MemoryContext rcontext)
{
 ArrayType  *arg;
 MemoryContext oldcontext;
 int     *dims,
      *lbs,
    ndims,
    nitems,
    ndatabytes;
 char    *data;
 int   i;
 int   newnitems;

 /*
  * 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);

 /* Check that the array doesn't grow too large */
 newnitems = astate->nitems + nitems;
 if (newnitems > MaxArraySize)
  ereport(ERROR,
    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     errmsg("array size exceeds the maximum allowed (%zu)",
      MaxArraySize)));

 if (astate->ndims == 0)
 {
  /* First input; check/save the dimensionality info */

  /* Should we allow empty inputs and just produce an empty output? */
  if (ndims == 0)
   ereport(ERROR,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("cannot accumulate empty arrays")));
  if (ndims + 1 > MAXDIM)
   ereport(ERROR,
     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
      errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
       ndims + 1, MAXDIM)));

  /*
   * The output array will have n+1 dimensions, with the ones after the
   * first matching the input's dimensions.
 */
  astate->ndims = ndims + 1;
  astate->dims[0] = 0;
  memcpy(&astate->dims[1], dims, ndims * sizeof(int));
  astate->lbs[0] = 1;
  memcpy(&astate->lbs[1], lbs, ndims * sizeof(int));

  /* Allocate at least enough data space for this item */
  astate->abytes = pg_nextpower2_32(Max(1024, ndatabytes + 1));
  astate->data = (char *) palloc(astate->abytes);
 }
 else
 {
  /* Second or later input: must match first input's dimensionality */
  if (astate->ndims != ndims + 1)
   ereport(ERROR,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("cannot accumulate arrays of different dimensionality")));
  for (i = 0; i < ndims; i++)
  {
   if (astate->dims[i + 1] != dims[i] || astate->lbs[i + 1] != lbs[i])
    ereport(ERROR,
      (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
       errmsg("cannot accumulate arrays of different dimensionality")));
  }

  /* Enlarge data space if needed */
  if (astate->nbytes + ndatabytes > astate->abytes)
  {
   astate->abytes = Max(astate->abytes * 2,
         astate->nbytes + ndatabytes);
   astate->data = (char *) repalloc(astate->data, astate->abytes);
  }
 }

 /*
  * Copy the data portion of the sub-array.  Note we assume that the
  * advertised data length of the sub-array is properly aligned.  We do not
  * have to worry about detoasting elements since whatever's in the
  * sub-array should be OK already.
 */
 memcpy(astate->data + astate->nbytes, data, ndatabytes);
 astate->nbytes += ndatabytes;

 /* Deal with null bitmap if needed */
 if (astate->nullbitmap || ARR_HASNULL(arg))
 {
  if (astate->nullbitmap == NULL)
  {
   /*
    * First input with nulls; we must retrospectively handle any
    * previous inputs by marking all their items non-null.
 */
   astate->aitems = pg_nextpower2_32(Max(256, newnitems + 1));
   astate->nullbitmap = (bits8 *) palloc((astate->aitems + 7) / 8);
   array_bitmap_copy(astate->nullbitmap, 0,
         NULL, 0,
         astate->nitems);
  }
  else if (newnitems > astate->aitems)
  {
   astate->aitems = Max(astate->aitems * 2, newnitems);
   astate->nullbitmap = (bits8 *)
    repalloc(astate->nullbitmap, (astate->aitems + 7) / 8);
  }
  array_bitmap_copy(astate->nullbitmap, astate->nitems,
        ARR_NULLBITMAP(arg), 0,
        nitems);
 }

 astate->nitems = newnitems;
 astate->dims[0] += 1;

 MemoryContextSwitchTo(oldcontext);

 /* Release detoasted copy if any */
 if ((Pointer) arg != DatumGetPointer(dvalue))
  pfree(arg);

 return astate;
}

/*
 * makeArrayResultArr - produce N+1-D final result of accumArrayResultArr
 *
 * astate is working state (must not be NULL)
 * rcontext is where to construct result
 * release is true if okay to release working state
 */
Datum
makeArrayResultArr(ArrayBuildStateArr *astate,
       MemoryContext rcontext,
       bool release)
{
 ArrayType  *result;
 MemoryContext oldcontext;

 /* Build the final array result in rcontext */
 oldcontext = MemoryContextSwitchTo(rcontext);

 if (astate->ndims == 0)
 {
  /* No inputs, return empty array */
  result = construct_empty_array(astate->element_type);
 }
 else
 {
  int   dataoffset,
     nbytes;

  /* Check for overflow of the array dimensions */
  (void) ArrayGetNItems(astate->ndims, astate->dims);
  ArrayCheckBounds(astate->ndims, astate->dims, astate->lbs);

  /* Compute required space */
  nbytes = astate->nbytes;
  if (astate->nullbitmap != NULL)
  {
   dataoffset = ARR_OVERHEAD_WITHNULLS(astate->ndims, astate->nitems);
   nbytes += dataoffset;
  }
  else
  {
   dataoffset = 0;
   nbytes += ARR_OVERHEAD_NONULLS(astate->ndims);
  }

  result = (ArrayType *) palloc0(nbytes);
  SET_VARSIZE(result, nbytes);
  result->ndim = astate->ndims;
  result->dataoffset = dataoffset;
  result->elemtype = astate->element_type;

  memcpy(ARR_DIMS(result), astate->dims, astate->ndims * sizeof(int));
  memcpy(ARR_LBOUND(result), astate->lbs, astate->ndims * sizeof(int));
  memcpy(ARR_DATA_PTR(result), astate->data, astate->nbytes);

  if (astate->nullbitmap != NULL)
   array_bitmap_copy(ARR_NULLBITMAP(result), 0,
         astate->nullbitmap, 0,
         astate->nitems);
 }

 MemoryContextSwitchTo(oldcontext);

 /* Clean up all the junk */
 if (release)
 {
  Assert(astate->private_cxt);
  MemoryContextDelete(astate->mcontext);
 }

 return PointerGetDatum(result);
}

/*
 * The following three functions provide essentially the same API as
 * initArrayResult/accumArrayResult/makeArrayResult, but can accept either
 * scalar or array inputs, invoking the appropriate set of functions above.
 */

/*
 * initArrayResultAny - initialize an empty ArrayBuildStateAny
 *
 * input_type is the input datatype (either element or array type)
 * rcontext is where to keep working state
 * subcontext is a flag determining whether to use a separate memory context
 */
ArrayBuildStateAny *
initArrayResultAny(Oid input_type, MemoryContext rcontext, bool subcontext)
{
 ArrayBuildStateAny *astate;

 /*
  * int2vector and oidvector will satisfy both get_element_type and
  * get_array_type.  We prefer to treat them as scalars, to be consistent
  * with get_promoted_array_type.  Hence, check get_array_type not
  * get_element_type.
 */
 if (!OidIsValid(get_array_type(input_type)))
 {
  /* Array case */
  ArrayBuildStateArr *arraystate;

  arraystate = initArrayResultArr(input_type, InvalidOid, rcontext, subcontext);
  astate = (ArrayBuildStateAny *)
   MemoryContextAlloc(arraystate->mcontext,
          sizeof(ArrayBuildStateAny));
  astate->scalarstate = NULL;
  astate->arraystate = arraystate;
 }
 else
 {
  /* Scalar case */
  ArrayBuildState *scalarstate;

  scalarstate = initArrayResult(input_type, rcontext, subcontext);
  astate = (ArrayBuildStateAny *)
   MemoryContextAlloc(scalarstate->mcontext,
          sizeof(ArrayBuildStateAny));
  astate->scalarstate = scalarstate;
  astate->arraystate = NULL;
 }

 return astate;
}

/*
 * accumArrayResultAny - accumulate one (more) input for an array result
 *
 * astate is working state (can be NULL on first call)
 * dvalue/disnull represent the new input to append to the array
 * input_type is the input datatype (either element or array type)
 * rcontext is where to keep working state
 */
ArrayBuildStateAny *
accumArrayResultAny(ArrayBuildStateAny *astate,
     Datum dvalue, bool disnull,
     Oid input_type,
     MemoryContext rcontext)
{
 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;
}

/*
 * makeArrayResultAny - produce final result of accumArrayResultAny
 *
 * astate is working state (must not be NULL)
 * rcontext is where to construct result
 * release is true if okay to release working state
 */
Datum
makeArrayResultAny(ArrayBuildStateAny *astate,
       MemoryContext rcontext, bool release)
{
 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
array_larger(PG_FUNCTION_ARGS)
{
 if (array_cmp(fcinfo) > 0)
  PG_RETURN_DATUM(PG_GETARG_DATUM(0));
 else
  PG_RETURN_DATUM(PG_GETARG_DATUM(1));
}

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


typedef struct generate_subscripts_fctx
{
 int32  lower;
 int32  upper;
 bool  reverse;
} generate_subscripts_fctx;

/*
 * generate_subscripts(array anyarray, dim int [, reverse bool])
 *  Returns all subscripts of the array for any dimension
 */
Datum
generate_subscripts(PG_FUNCTION_ARGS)
{
 FuncCallContext *funcctx;
 MemoryContext oldcontext;
 generate_subscripts_fctx *fctx;

 /* stuff done only on the first call of the function */
 if (SRF_IS_FIRSTCALL())
 {
  AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
  int   reqdim = PG_GETARG_INT32(1);
  int     *lb,
       *dimv;

  /* create a function context for cross-call persistence */
  funcctx = SRF_FIRSTCALL_INIT();

  /* Sanity check: does it look like an array at all? */
  if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
   SRF_RETURN_DONE(funcctx);

  /* Sanity check: was the requested dim valid */
  if (reqdim <= 0 || reqdim > AARR_NDIM(v))
   SRF_RETURN_DONE(funcctx);

  /*
   * switch to memory context appropriate for multiple function calls
 */
  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
  fctx = (generate_subscripts_fctx *) palloc(sizeof(generate_subscripts_fctx));

  lb = AARR_LBOUND(v);
  dimv = AARR_DIMS(v);

  fctx->lower = lb[reqdim - 1];
  fctx->upper = dimv[reqdim - 1] + lb[reqdim - 1] - 1;
  fctx->reverse = (PG_NARGS() < 3) ? false : PG_GETARG_BOOL(2);

  funcctx->user_fctx = fctx;

  MemoryContextSwitchTo(oldcontext);
 }

 funcctx = SRF_PERCALL_SETUP();

 fctx = funcctx->user_fctx;

 if (fctx->lower <= fctx->upper)
 {
  if (!fctx->reverse)
   SRF_RETURN_NEXT(funcctx, Int32GetDatum(fctx->lower++));
  else
   SRF_RETURN_NEXT(funcctx, Int32GetDatum(fctx->upper--));
 }
 else
  /* done when there are no more elements left */
  SRF_RETURN_DONE(funcctx);
}

/*
 * generate_subscripts_nodir
 *  Implements the 2-argument version of generate_subscripts
 */
Datum
generate_subscripts_nodir(PG_FUNCTION_ARGS)
{
 /* just call the other one -- it can handle both cases */
 return generate_subscripts(fcinfo);
}

/*
 * array_fill_with_lower_bounds
 *  Create and fill array with defined lower bounds.
 */
Datum
array_fill_with_lower_bounds(PG_FUNCTION_ARGS)
{
 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);
}

/*
 * array_fill
 *  Create and fill array with default lower bounds.
 */
Datum
array_fill(PG_FUNCTION_ARGS)
{
 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 *
create_array_envelope(int ndims, int *dimv, int *lbsv, int nbytes,
       Oid elmtype, int dataoffset)
{
 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;
}

static ArrayType *
array_fill_internal(ArrayType *dims, ArrayType *lbs,
     Datum value, bool isnull, Oid elmtype,
     FunctionCallInfo fcinfo)
{
 ArrayType  *result;
 int     *dimv;
 int     *lbsv;
 int   ndims;
 int   nitems;
 int   deflbs[MAXDIM];
 int16  elmlen;
 bool  elmbyval;
 char  elmalign;
 ArrayMetaState *my_extra;

 /*
  * Params checks
 */
 if (ARR_NDIM(dims) > 1)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("wrong number of array subscripts"),
     errdetail("Dimension array must be one dimensional.")));

 if (array_contains_nulls(dims))
  ereport(ERROR,
    (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
     errmsg("dimension values cannot be null")));

 dimv = (int *) ARR_DATA_PTR(dims);
 ndims = (ARR_NDIM(dims) > 0) ? ARR_DIMS(dims)[0] : 0;

 if (ndims < 0)    /* we do allow zero-dimension arrays */
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     errmsg("invalid number of dimensions: %d", ndims)));
 if (ndims > MAXDIM)
  ereport(ERROR,
    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
      ndims, MAXDIM)));

 if (lbs != NULL)
 {
  if (ARR_NDIM(lbs) > 1)
   ereport(ERROR,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("wrong number of array subscripts"),
      errdetail("Dimension array must be one dimensional.")));

  if (array_contains_nulls(lbs))
   ereport(ERROR,
     (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
      errmsg("dimension values cannot be null")));

  if (ndims != ((ARR_NDIM(lbs) > 0) ? ARR_DIMS(lbs)[0] : 0))
   ereport(ERROR,
     (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
      errmsg("wrong number of array subscripts"),
      errdetail("Low bound array has different size than dimensions array.")));

  lbsv = (int *) ARR_DATA_PTR(lbs);
 }
 else
 {
  int   i;

  for (i = 0; i < MAXDIM; i++)
   deflbs[i] = 1;

  lbsv = deflbs;
 }

 /* This checks for overflow of the array dimensions */
 nitems = ArrayGetNItems(ndims, dimv);
 ArrayCheckBounds(ndims, dimv, lbsv);

 /* fast track for empty array */
 if (nitems <= 0)
  return construct_empty_array(elmtype);

 /*
  * We arrange to look up info about element type only once per series of
  * calls, assuming the element type doesn't change underneath us.
 */
 my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
 if (my_extra == NULL)
 {
  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
               sizeof(ArrayMetaState));
  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
  my_extra->element_type = InvalidOid;
 }

 if (my_extra->element_type != elmtype)
 {
  /* Get info about element type */
  get_typlenbyvalalign(elmtype,
        &my_extra->typlen,
        &my_extra->typbyval,
        &my_extra->typalign);
  my_extra->element_type = elmtype;
 }

 elmlen = my_extra->typlen;
 elmbyval = my_extra->typbyval;
 elmalign = my_extra->typalign;

 /* compute required space */
 if (!isnull)
 {
  int   i;
  char    *p;
  int   nbytes;
  int   totbytes;

  /* make sure data is not toasted */
  if (elmlen == -1)
   value = PointerGetDatum(PG_DETOAST_DATUM(value));

  nbytes = att_addlength_datum(0, elmlen, value);
  nbytes = att_align_nominal(nbytes, elmalign);
  Assert(nbytes > 0);

  totbytes = nbytes * nitems;

  /* check for overflow of multiplication or total request */
  if (totbytes / nbytes != nitems ||
   !AllocSizeIsValid(totbytes))
   ereport(ERROR,
     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
      errmsg("array size exceeds the maximum allowed (%d)",
       (int) MaxAllocSize)));

  /*
   * This addition can't overflow, but it might cause us to go past
   * MaxAllocSize.  We leave it to palloc to complain in that case.
 */
  totbytes += ARR_OVERHEAD_NONULLS(ndims);

  result = create_array_envelope(ndims, dimv, lbsv, totbytes,
            elmtype, 0);

  p = ARR_DATA_PTR(result);
  for (i = 0; i < nitems; i++)
   p += ArrayCastAndSet(value, elmlen, elmbyval, elmalign, p);
 }
 else
 {
  int   nbytes;
  int   dataoffset;

  dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
  nbytes = dataoffset;

  result = create_array_envelope(ndims, dimv, lbsv, nbytes,
            elmtype, dataoffset);

  /* create_array_envelope already zeroed the bitmap, so we're done */
 }

 return result;
}


/*
 * UNNEST
 */
Datum
array_unnest(PG_FUNCTION_ARGS)
{
 typedef struct
 {
  array_iter iter;
  int   nextelem;
  int   numelems;
  int16  elmlen;
  bool  elmbyval;
  char  elmalign;
 } array_unnest_fctx;

 FuncCallContext *funcctx;
 array_unnest_fctx *fctx;
 MemoryContext oldcontext;

 /* stuff done only on the first call of the function */
 if (SRF_IS_FIRSTCALL())
 {
  AnyArrayType *arr;

  /* create a function context for cross-call persistence */
  funcctx = SRF_FIRSTCALL_INIT();

  /*
   * switch to memory context appropriate for multiple function calls
 */
  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

  /*
   * Get the array value and detoast if needed.  We can't do this
   * earlier because if we have to detoast, we want the detoasted copy
   * to be in multi_call_memory_ctx, so it will go away when we're done
   * and not before.  (If no detoast happens, we assume the originally
   * passed array will stick around till then.)
 */
  arr = PG_GETARG_ANY_ARRAY_P(0);

  /* allocate memory for user context */
  fctx = (array_unnest_fctx *) palloc(sizeof(array_unnest_fctx));

  /* initialize state */
  array_iter_setup(&fctx->iter, arr);
  fctx->nextelem = 0;
  fctx->numelems = ArrayGetNItems(AARR_NDIM(arr), AARR_DIMS(arr));

  if (VARATT_IS_EXPANDED_HEADER(arr))
  {
   /* we can just grab the type data from expanded array */
   fctx->elmlen = arr->xpn.typlen;
   fctx->elmbyval = arr->xpn.typbyval;
   fctx->elmalign = arr->xpn.typalign;
  }
  else
   get_typlenbyvalalign(AARR_ELEMTYPE(arr),
         &fctx->elmlen,
         &fctx->elmbyval,
         &fctx->elmalign);

  funcctx->user_fctx = fctx;
  MemoryContextSwitchTo(oldcontext);
 }

 /* stuff done on every call of the function */
 funcctx = SRF_PERCALL_SETUP();
 fctx = funcctx->user_fctx;

 if (fctx->nextelem < fctx->numelems)
 {
  int   offset = fctx->nextelem++;
  Datum  elem;

  elem = array_iter_next(&fctx->iter, &fcinfo->isnull, offset,
          fctx->elmlen, fctx->elmbyval, fctx->elmalign);

  SRF_RETURN_NEXT(funcctx, elem);
 }
 else
 {
  /* do when there is no more left */
  SRF_RETURN_DONE(funcctx);
 }
}

/*
 * Planner support function for array_unnest(anyarray)
 *
 * Note: this is now also used for information_schema._pg_expandarray(),
 * which is simply a wrapper around array_unnest().
 */
Datum
array_unnest_support(PG_FUNCTION_ARGS)
{
 Node    *rawreq = (Node *) PG_GETARG_POINTER(0);
 Node    *ret = NULL;

 if (IsA(rawreq, SupportRequestRows))
 {
  /* Try to estimate the number of rows returned */
  SupportRequestRows *req = (SupportRequestRows *) rawreq;

  if (is_funcclause(req->node)) /* be paranoid */
  {
   List    *args = ((FuncExpr *) req->node)->args;
   Node    *arg1;

   /* We can use estimated argument values here */
   arg1 = estimate_expression_value(req->root, linitial(args));

   req->rows = estimate_array_length(req->root, arg1);
   ret = (Node *) req;
  }
 }

 PG_RETURN_POINTER(ret);
}


/*
 * array_replace/array_remove support
 *
 * Find all array entries matching (not distinct from) search/search_isnull,
 * and delete them if remove is true, else replace them with
 * replace/replace_isnull.  Comparisons are done using the specified
 * collation.  fcinfo is passed only for caching purposes.
 */
static ArrayType *
array_replace_internal(ArrayType *array,
        Datum search, bool search_isnull,
        Datum replace, bool replace_isnull,
        bool remove, Oid collation,
        FunctionCallInfo fcinfo)
{
 LOCAL_FCINFO(locfcinfo, 2);
 ArrayType  *result;
 Oid   element_type;
 Datum    *values;
 bool    *nulls;
 int     *dim;
 int   ndim;
 int   nitems,
    nresult;
 int   i;
 int32  nbytes = 0;
 int32  dataoffset;
 bool  hasnulls;
 int   typlen;
 bool  typbyval;
 char  typalign;
 char    *arraydataptr;
 bits8    *bitmap;
 int   bitmask;
 bool  changed = false;
 TypeCacheEntry *typentry;

 element_type = ARR_ELEMTYPE(array);
 ndim = ARR_NDIM(array);
 dim = ARR_DIMS(array);
 nitems = ArrayGetNItems(ndim, dim);

 /* Return input array unmodified if it is empty */
 if (nitems <= 0)
  return array;

 /*
  * We can't remove elements from multi-dimensional arrays, since the
  * result might not be rectangular.
 */
 if (remove && ndim > 1)
  ereport(ERROR,
    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     errmsg("removing elements from multidimensional arrays is not supported")));

 /*
  * We arrange to look up the equality function only once per series of
  * calls, assuming the element type doesn't change underneath us.
 */
 typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
 if (typentry == NULL ||
  typentry->type_id != element_type)
 {
  typentry = lookup_type_cache(element_type,
          TYPECACHE_EQ_OPR_FINFO);
  if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
   ereport(ERROR,
     (errcode(ERRCODE_UNDEFINED_FUNCTION),
      errmsg("could not identify an equality operator for type %s",
       format_type_be(element_type))));
  fcinfo->flinfo->fn_extra = typentry;
 }
 typlen = typentry->typlen;
 typbyval = typentry->typbyval;
 typalign = typentry->typalign;

 /*
  * Detoast values if they are toasted.  The replacement value must be
  * detoasted for insertion into the result array, while detoasting the
  * search value only once saves cycles.
 */
 if (typlen == -1)
 {
  if (!search_isnull)
   search = PointerGetDatum(PG_DETOAST_DATUM(search));
  if (!replace_isnull)
   replace = PointerGetDatum(PG_DETOAST_DATUM(replace));
 }

 /* Prepare to apply the comparison operator */
 InitFunctionCallInfoData(*locfcinfo, &typentry->eq_opr_finfo, 2,
        collation, NULL, NULL);

 /* Allocate temporary arrays for new values */
 values = (Datum *) palloc(nitems * sizeof(Datum));
 nulls = (bool *) palloc(nitems * sizeof(bool));

 /* Loop over source data */
 arraydataptr = ARR_DATA_PTR(array);
 bitmap = ARR_NULLBITMAP(array);
 bitmask = 1;
 hasnulls = false;
 nresult = 0;

 for (i = 0; i < nitems; i++)
 {
  Datum  elt;
  bool  isNull;
  bool  oprresult;
  bool  skip = false;

  /* Get source element, checking for NULL */
  if (bitmap && (*bitmap & bitmask) == 0)
  {
   isNull = true;
   /* If searching for NULL, we have a match */
   if (search_isnull)
   {
    if (remove)
    {
     skip = true;
     changed = true;
    }
    else if (!replace_isnull)
    {
     values[nresult] = replace;
     isNull = false;
     changed = true;
    }
   }
  }
  else
  {
   isNull = false;
   elt = fetch_att(arraydataptr, typbyval, typlen);
   arraydataptr = att_addlength_datum(arraydataptr, typlen, elt);
   arraydataptr = (char *) att_align_nominal(arraydataptr, typalign);

   if (search_isnull)
   {
    /* no match possible, keep element */
    values[nresult] = elt;
   }
   else
   {
    /*
     * Apply the operator to the element pair; treat NULL as false
 */
    locfcinfo->args[0].value = elt;
    locfcinfo->args[0].isnull = false;
    locfcinfo->args[1].value = search;
    locfcinfo->args[1].isnull = false;
    locfcinfo->isnull = false;
    oprresult = DatumGetBool(FunctionCallInvoke(locfcinfo));
    if (locfcinfo->isnull || !oprresult)
    {
     /* no match, keep element */
     values[nresult] = elt;
    }
    else
    {
     /* match, so replace or delete */
     changed = true;
     if (remove)
      skip = true;
     else
     {
      values[nresult] = replace;
      isNull = replace_isnull;
     }
    }
   }
  }

  if (!skip)
  {
   nulls[nresult] = isNull;
   if (isNull)
    hasnulls = true;
   else
   {
    /* Update total result size */
    nbytes = att_addlength_datum(nbytes, typlen, values[nresult]);
    nbytes = att_align_nominal(nbytes, typalign);
    /* check for overflow of total request */
    if (!AllocSizeIsValid(nbytes))
     ereport(ERROR,
       (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
        errmsg("array size exceeds the maximum allowed (%d)",
         (int) MaxAllocSize)));
   }
   nresult++;
  }

  /* advance bitmap pointer if any */
  if (bitmap)
  {
   bitmask <<= 1;
   if (bitmask == 0x100)
   {
    bitmap++;
    bitmask = 1;
   }
  }
 }

 /*
  * If not changed just return the original array
 */
 if (!changed)
 {
  pfree(values);
  pfree(nulls);
  return array;
 }

 /* If all elements were removed return an empty array */
 if (nresult == 0)
 {
  pfree(values);
  pfree(nulls);
  return construct_empty_array(element_type);
 }

 /* Allocate and initialize the result array */
 if (hasnulls)
 {
  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nresult);
  nbytes += dataoffset;
 }
 else
 {
  dataoffset = 0;   /* marker for no null bitmap */
  nbytes += ARR_OVERHEAD_NONULLS(ndim);
 }
 result = (ArrayType *) palloc0(nbytes);
 SET_VARSIZE(result, nbytes);
 result->ndim = ndim;
 result->dataoffset = dataoffset;
 result->elemtype = element_type;
 memcpy(ARR_DIMS(result), ARR_DIMS(array), ndim * sizeof(int));
 memcpy(ARR_LBOUND(result), ARR_LBOUND(array), ndim * sizeof(int));

 if (remove)
 {
  /* Adjust the result length */
  ARR_DIMS(result)[0] = nresult;
 }

 /* Insert data into result array */
 CopyArrayEls(result,
     values, nulls, nresult,
     typlen, typbyval, typalign,
     false);

 pfree(values);
 pfree(nulls);

 return result;
}

/*
 * Remove any occurrences of an element from an array
 *
 * If used on a multi-dimensional array this will raise an error.
 */
Datum
array_remove(PG_FUNCTION_ARGS)
{
 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);
}

/*
 * Replace any occurrences of an element in an array
 */
Datum
array_replace(PG_FUNCTION_ARGS)
{
 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);
}

/*
 * Implements width_bucket(anyelement, anyarray).
 *
 * 'thresholds' is an array containing lower bound values for each bucket;
 * these must be sorted from smallest to largest, or bogus results will be
 * produced.  If N thresholds are supplied, the output is from 0 to N:
 * 0 is for inputs < first threshold, N is for inputs >= last threshold.
 */
Datum
width_bucket_array(PG_FUNCTION_ARGS)
{
 Datum  operand = PG_GETARG_DATUM(0);
 ArrayType  *thresholds = PG_GETARG_ARRAYTYPE_P(1);
 Oid   collation = PG_GET_COLLATION();
 Oid   element_type = ARR_ELEMTYPE(thresholds);
 int   result;

 /* Check input */
 if (ARR_NDIM(thresholds) > 1)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("thresholds must be one-dimensional array")));

 if (array_contains_nulls(thresholds))
  ereport(ERROR,
    (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
     errmsg("thresholds array must not contain NULLs")));

 /* We have a dedicated implementation for float8 data */
 if (element_type == FLOAT8OID)
  result = width_bucket_array_float8(operand, thresholds);
 else
 {
  TypeCacheEntry *typentry;

  /* Cache information about the input type */
  typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
  if (typentry == NULL ||
   typentry->type_id != element_type)
  {
   typentry = lookup_type_cache(element_type,
           TYPECACHE_CMP_PROC_FINFO);
   if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
    ereport(ERROR,
      (errcode(ERRCODE_UNDEFINED_FUNCTION),
       errmsg("could not identify a comparison function for type %s",
        format_type_be(element_type))));
   fcinfo->flinfo->fn_extra = typentry;
  }

  /*
   * We have separate implementation paths for fixed- and variable-width
   * types, since indexing the array is a lot cheaper in the first case.
 */
  if (typentry->typlen > 0)
   result = width_bucket_array_fixed(operand, thresholds,
             collation, typentry);
  else
   result = width_bucket_array_variable(operand, thresholds,
             collation, typentry);
 }

 /* Avoid leaking memory when handed toasted input. */
 PG_FREE_IF_COPY(thresholds, 1);

 PG_RETURN_INT32(result);
}

/*
 * width_bucket_array for float8 data.
 */
static int
width_bucket_array_float8(Datum operand, ArrayType *thresholds)
{
 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;
}

/*
 * width_bucket_array for generic fixed-width data types.
 */
static int
width_bucket_array_fixed(Datum operand,
       ArrayType *thresholds,
       Oid collation,
       TypeCacheEntry *typentry)
{
 LOCAL_FCINFO(locfcinfo, 2);
 char    *thresholds_data;
 int   typlen = typentry->typlen;
 bool  typbyval = typentry->typbyval;
 int   left;
 int   right;

 /*
  * Since we know the array contains no NULLs, we can just index it
  * directly.
 */
 thresholds_data = (char *) ARR_DATA_PTR(thresholds);

 InitFunctionCallInfoData(*locfcinfo, &typentry->cmp_proc_finfo, 2,
        collation, NULL, NULL);

 /* Find the bucket */
 left = 0;
 right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
 while (left < right)
 {
  int   mid = (left + right) / 2;
  char    *ptr;
  int32  cmpresult;

  ptr = thresholds_data + mid * typlen;

  locfcinfo->args[0].value = operand;
  locfcinfo->args[0].isnull = false;
  locfcinfo->args[1].value = fetch_att(ptr, typbyval, typlen);
  locfcinfo->args[1].isnull = false;

  cmpresult = DatumGetInt32(FunctionCallInvoke(locfcinfo));

  /* We don't expect comparison support functions to return null */
  Assert(!locfcinfo->isnull);

  if (cmpresult < 0)
   right = mid;
  else
   left = mid + 1;
 }

 return left;
}

/*
 * width_bucket_array for generic variable-width data types.
 */
static int
width_bucket_array_variable(Datum operand,
       ArrayType *thresholds,
       Oid collation,
       TypeCacheEntry *typentry)
{
 LOCAL_FCINFO(locfcinfo, 2);
 char    *thresholds_data;
 int   typlen = typentry->typlen;
 bool  typbyval = typentry->typbyval;
 char  typalign = typentry->typalign;
 int   left;
 int   right;

 thresholds_data = (char *) ARR_DATA_PTR(thresholds);

 InitFunctionCallInfoData(*locfcinfo, &typentry->cmp_proc_finfo, 2,
        collation, NULL, NULL);

 /* Find the bucket */
 left = 0;
 right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
 while (left < right)
 {
  int   mid = (left + right) / 2;
  char    *ptr;
  int   i;
  int32  cmpresult;

  /* Locate mid'th array element by advancing from left element */
  ptr = thresholds_data;
  for (i = left; i < mid; i++)
  {
   ptr = att_addlength_pointer(ptr, typlen, ptr);
   ptr = (char *) att_align_nominal(ptr, typalign);
  }

  locfcinfo->args[0].value = operand;
  locfcinfo->args[0].isnull = false;
  locfcinfo->args[1].value = fetch_att(ptr, typbyval, typlen);
  locfcinfo->args[1].isnull = false;

  cmpresult = DatumGetInt32(FunctionCallInvoke(locfcinfo));

  /* We don't expect comparison support functions to return null */
  Assert(!locfcinfo->isnull);

  if (cmpresult < 0)
   right = mid;
  else
  {
   left = mid + 1;

   /*
    * Move the thresholds pointer to match new "left" index, so we
    * don't have to seek over those elements again.  This trick
    * ensures we do only O(N) array indexing work, not O(N^2).
 */
   ptr = att_addlength_pointer(ptr, typlen, ptr);
   thresholds_data = (char *) att_align_nominal(ptr, typalign);
  }
 }

 return left;
}

/*
 * Trim the last N elements from an array by building an appropriate slice.
 * Only the first dimension is trimmed.
 */
Datum
trim_array(PG_FUNCTION_ARGS)
{
 ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);
 int   n = PG_GETARG_INT32(1);
 int   array_length = (ARR_NDIM(v) > 0) ? ARR_DIMS(v)[0] : 0;
 int16  elmlen;
 bool  elmbyval;
 char  elmalign;
 int   lower[MAXDIM];
 int   upper[MAXDIM];
 bool  lowerProvided[MAXDIM];
 bool  upperProvided[MAXDIM];
 Datum  result;

 /* Per spec, throw an error if out of bounds */
 if (n < 0 || n > array_length)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_ELEMENT_ERROR),
     errmsg("number of elements to trim must be between 0 and %d",
      array_length)));

 /* Set all the bounds as unprovided except the first upper bound */
 memset(lowerProvided, false, sizeof(lowerProvided));
 memset(upperProvided, false, sizeof(upperProvided));
 if (ARR_NDIM(v) > 0)
 {
  upper[0] = ARR_LBOUND(v)[0] + array_length - n - 1;
  upperProvided[0] = true;
 }

 /* Fetch the needed information about the element type */
 get_typlenbyvalalign(ARR_ELEMTYPE(v), &elmlen, &elmbyval, &elmalign);

 /* Get the slice */
 result = array_get_slice(PointerGetDatum(v), 1,
        upper, lower, upperProvided, lowerProvided,
        -1, elmlen, elmbyval, elmalign);

 PG_RETURN_DATUM(result);
}