PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
arrayfuncs.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * arrayfuncs.c
4  * Support functions for arrays.
5  *
6  * Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/utils/adt/arrayfuncs.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include <ctype.h>
18 #ifdef _MSC_VER
19 #include <float.h> /* for _isnan */
20 #endif
21 #include <math.h>
22 
23 #include "access/htup_details.h"
24 #include "catalog/pg_type.h"
25 #include "funcapi.h"
26 #include "libpq/pqformat.h"
27 #include "utils/array.h"
28 #include "utils/arrayaccess.h"
29 #include "utils/builtins.h"
30 #include "utils/datum.h"
31 #include "utils/lsyscache.h"
32 #include "utils/memutils.h"
33 #include "utils/typcache.h"
34 
35 
36 /*
37  * GUC parameter
38  */
39 bool Array_nulls = true;
40 
41 /*
42  * Local definitions
43  */
44 #define ASSGN "="
45 
46 #define AARR_FREE_IF_COPY(array,n) \
47  do { \
48  if (!VARATT_IS_EXPANDED_HEADER(array)) \
49  PG_FREE_IF_COPY(array, n); \
50  } while (0)
51 
52 typedef enum
53 {
54  ARRAY_NO_LEVEL,
55  ARRAY_LEVEL_STARTED,
56  ARRAY_ELEM_STARTED,
57  ARRAY_ELEM_COMPLETED,
58  ARRAY_QUOTED_ELEM_STARTED,
59  ARRAY_QUOTED_ELEM_COMPLETED,
60  ARRAY_ELEM_DELIMITED,
61  ARRAY_LEVEL_COMPLETED,
62  ARRAY_LEVEL_DELIMITED
63 } ArrayParseState;
64 
65 /* Working state for array_iterate() */
66 typedef struct ArrayIteratorData
67 {
68  /* basic info about the array, set up during array_create_iterator() */
69  ArrayType *arr; /* array we're iterating through */
70  bits8 *nullbitmap; /* its null bitmap, if any */
71  int nitems; /* total number of elements in array */
72  int16 typlen; /* element type's length */
73  bool typbyval; /* element type's byval property */
74  char typalign; /* element type's align property */
75 
76  /* information about the requested slice size */
77  int slice_ndim; /* slice dimension, or 0 if not slicing */
78  int slice_len; /* number of elements per slice */
79  int *slice_dims; /* slice dims array */
80  int *slice_lbound; /* slice lbound array */
81  Datum *slice_values; /* workspace of length slice_len */
82  bool *slice_nulls; /* workspace of length slice_len */
83 
84  /* current position information, updated on each iteration */
85  char *data_ptr; /* our current position in the array */
86  int current_item; /* the item # we're at in the array */
87 } ArrayIteratorData;
88 
89 static bool array_isspace(char ch);
90 static int ArrayCount(const char *str, int *dim, char typdelim);
91 static void ReadArrayStr(char *arrayStr, const char *origStr,
92  int nitems, int ndim, int *dim,
93  FmgrInfo *inputproc, Oid typioparam, int32 typmod,
94  char typdelim,
95  int typlen, bool typbyval, char typalign,
96  Datum *values, bool *nulls,
97  bool *hasnulls, int32 *nbytes);
98 static void ReadArrayBinary(StringInfo buf, int nitems,
99  FmgrInfo *receiveproc, Oid typioparam, int32 typmod,
100  int typlen, bool typbyval, char typalign,
101  Datum *values, bool *nulls,
102  bool *hasnulls, int32 *nbytes);
103 static Datum array_get_element_expanded(Datum arraydatum,
104  int nSubscripts, int *indx,
105  int arraytyplen,
106  int elmlen, bool elmbyval, char elmalign,
107  bool *isNull);
108 static Datum array_set_element_expanded(Datum arraydatum,
109  int nSubscripts, int *indx,
110  Datum dataValue, bool isNull,
111  int arraytyplen,
112  int elmlen, bool elmbyval, char elmalign);
113 static bool array_get_isnull(const bits8 *nullbitmap, int offset);
114 static void array_set_isnull(bits8 *nullbitmap, int offset, bool isNull);
115 static Datum ArrayCast(char *value, bool byval, int len);
116 static int ArrayCastAndSet(Datum src,
117  int typlen, bool typbyval, char typalign,
118  char *dest);
119 static char *array_seek(char *ptr, int offset, bits8 *nullbitmap, int nitems,
120  int typlen, bool typbyval, char typalign);
121 static int array_nelems_size(char *ptr, int offset, bits8 *nullbitmap,
122  int nitems, int typlen, bool typbyval, char typalign);
123 static int array_copy(char *destptr, int nitems,
124  char *srcptr, int offset, bits8 *nullbitmap,
125  int typlen, bool typbyval, char typalign);
126 static int array_slice_size(char *arraydataptr, bits8 *arraynullsptr,
127  int ndim, int *dim, int *lb,
128  int *st, int *endp,
129  int typlen, bool typbyval, char typalign);
130 static void array_extract_slice(ArrayType *newarray,
131  int ndim, int *dim, int *lb,
132  char *arraydataptr, bits8 *arraynullsptr,
133  int *st, int *endp,
134  int typlen, bool typbyval, char typalign);
135 static void array_insert_slice(ArrayType *destArray, ArrayType *origArray,
136  ArrayType *srcArray,
137  int ndim, int *dim, int *lb,
138  int *st, int *endp,
139  int typlen, bool typbyval, char typalign);
140 static int array_cmp(FunctionCallInfo fcinfo);
141 static ArrayType *create_array_envelope(int ndims, int *dimv, int *lbv, int nbytes,
142  Oid elmtype, int dataoffset);
143 static ArrayType *array_fill_internal(ArrayType *dims, ArrayType *lbs,
144  Datum value, bool isnull, Oid elmtype,
145  FunctionCallInfo fcinfo);
146 static ArrayType *array_replace_internal(ArrayType *array,
147  Datum search, bool search_isnull,
148  Datum replace, bool replace_isnull,
149  bool remove, Oid collation,
150  FunctionCallInfo fcinfo);
151 static int width_bucket_array_float8(Datum operand, ArrayType *thresholds);
152 static int width_bucket_array_fixed(Datum operand,
153  ArrayType *thresholds,
154  Oid collation,
155  TypeCacheEntry *typentry);
156 static int width_bucket_array_variable(Datum operand,
157  ArrayType *thresholds,
158  Oid collation,
159  TypeCacheEntry *typentry);
160 
161 
162 /*
163  * array_in :
164  * converts an array from the external format in "string" to
165  * its internal format.
166  *
167  * return value :
168  * the internal representation of the input array
169  */
170 Datum
171 array_in(PG_FUNCTION_ARGS)
172 {
173  char *string = PG_GETARG_CSTRING(0); /* external form */
174  Oid element_type = PG_GETARG_OID(1); /* type of an array
175  * element */
176  int32 typmod = PG_GETARG_INT32(2); /* typmod for array elements */
177  int typlen;
178  bool typbyval;
179  char typalign;
180  char typdelim;
181  Oid typioparam;
182  char *string_save,
183  *p;
184  int i,
185  nitems;
186  Datum *dataPtr;
187  bool *nullsPtr;
188  bool hasnulls;
189  int32 nbytes;
190  int32 dataoffset;
191  ArrayType *retval;
192  int ndim,
193  dim[MAXDIM],
194  lBound[MAXDIM];
195  ArrayMetaState *my_extra;
196 
197  /*
198  * We arrange to look up info about element type, including its input
199  * conversion proc, only once per series of calls, assuming the element
200  * type doesn't change underneath us.
201  */
202  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
203  if (my_extra == NULL)
204  {
205  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
206  sizeof(ArrayMetaState));
207  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
208  my_extra->element_type = ~element_type;
209  }
210 
211  if (my_extra->element_type != element_type)
212  {
213  /*
214  * Get info about element type, including its input conversion proc
215  */
216  get_type_io_data(element_type, IOFunc_input,
217  &my_extra->typlen, &my_extra->typbyval,
218  &my_extra->typalign, &my_extra->typdelim,
219  &my_extra->typioparam, &my_extra->typiofunc);
220  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
221  fcinfo->flinfo->fn_mcxt);
222  my_extra->element_type = element_type;
223  }
224  typlen = my_extra->typlen;
225  typbyval = my_extra->typbyval;
226  typalign = my_extra->typalign;
227  typdelim = my_extra->typdelim;
228  typioparam = my_extra->typioparam;
229 
230  /* Make a modifiable copy of the input */
231  string_save = pstrdup(string);
232 
233  /*
234  * If the input string starts with dimension info, read and use that.
235  * Otherwise, we require the input to be in curly-brace style, and we
236  * prescan the input to determine dimensions.
237  *
238  * Dimension info takes the form of one or more [n] or [m:n] items. The
239  * outer loop iterates once per dimension item.
240  */
241  p = string_save;
242  ndim = 0;
243  for (;;)
244  {
245  char *q;
246  int ub;
247 
248  /*
249  * Note: we currently allow whitespace between, but not within,
250  * dimension items.
251  */
252  while (array_isspace(*p))
253  p++;
254  if (*p != '[')
255  break; /* no more dimension items */
256  p++;
257  if (ndim >= MAXDIM)
258  ereport(ERROR,
259  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
260  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
261  ndim + 1, MAXDIM)));
262 
263  for (q = p; isdigit((unsigned char) *q) || (*q == '-') || (*q == '+'); q++)
264  /* skip */ ;
265  if (q == p) /* no digits? */
266  ereport(ERROR,
267  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
268  errmsg("malformed array literal: \"%s\"", string),
269  errdetail("\"[\" must introduce explicitly-specified array dimensions.")));
270 
271  if (*q == ':')
272  {
273  /* [m:n] format */
274  *q = '\0';
275  lBound[ndim] = atoi(p);
276  p = q + 1;
277  for (q = p; isdigit((unsigned char) *q) || (*q == '-') || (*q == '+'); q++)
278  /* skip */ ;
279  if (q == p) /* no digits? */
280  ereport(ERROR,
281  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
282  errmsg("malformed array literal: \"%s\"", string),
283  errdetail("Missing array dimension value.")));
284  }
285  else
286  {
287  /* [n] format */
288  lBound[ndim] = 1;
289  }
290  if (*q != ']')
291  ereport(ERROR,
292  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
293  errmsg("malformed array literal: \"%s\"", string),
294  errdetail("Missing \"%s\" after array dimensions.",
295  "]")));
296 
297  *q = '\0';
298  ub = atoi(p);
299  p = q + 1;
300  if (ub < lBound[ndim])
301  ereport(ERROR,
302  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
303  errmsg("upper bound cannot be less than lower bound")));
304 
305  dim[ndim] = ub - lBound[ndim] + 1;
306  ndim++;
307  }
308 
309  if (ndim == 0)
310  {
311  /* No array dimensions, so intuit dimensions from brace structure */
312  if (*p != '{')
313  ereport(ERROR,
314  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
315  errmsg("malformed array literal: \"%s\"", string),
316  errdetail("Array value must start with \"{\" or dimension information.")));
317  ndim = ArrayCount(p, dim, typdelim);
318  for (i = 0; i < ndim; i++)
319  lBound[i] = 1;
320  }
321  else
322  {
323  int ndim_braces,
324  dim_braces[MAXDIM];
325 
326  /* If array dimensions are given, expect '=' operator */
327  if (strncmp(p, ASSGN, strlen(ASSGN)) != 0)
328  ereport(ERROR,
329  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
330  errmsg("malformed array literal: \"%s\"", string),
331  errdetail("Missing \"%s\" after array dimensions.",
332  ASSGN)));
333  p += strlen(ASSGN);
334  while (array_isspace(*p))
335  p++;
336 
337  /*
338  * intuit dimensions from brace structure -- it better match what we
339  * were given
340  */
341  if (*p != '{')
342  ereport(ERROR,
343  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
344  errmsg("malformed array literal: \"%s\"", string),
345  errdetail("Array contents must start with \"{\".")));
346  ndim_braces = ArrayCount(p, dim_braces, typdelim);
347  if (ndim_braces != ndim)
348  ereport(ERROR,
349  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
350  errmsg("malformed array literal: \"%s\"", string),
351  errdetail("Specified array dimensions do not match array contents.")));
352  for (i = 0; i < ndim; ++i)
353  {
354  if (dim[i] != dim_braces[i])
355  ereport(ERROR,
356  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
357  errmsg("malformed array literal: \"%s\"", string),
358  errdetail("Specified array dimensions do not match array contents.")));
359  }
360  }
361 
362 #ifdef ARRAYDEBUG
363  printf("array_in- ndim %d (", ndim);
364  for (i = 0; i < ndim; i++)
365  {
366  printf(" %d", dim[i]);
367  };
368  printf(") for %s\n", string);
369 #endif
370 
371  /* This checks for overflow of the array dimensions */
372  nitems = ArrayGetNItems(ndim, dim);
373  /* Empty array? */
374  if (nitems == 0)
375  PG_RETURN_ARRAYTYPE_P(construct_empty_array(element_type));
376 
377  dataPtr = (Datum *) palloc(nitems * sizeof(Datum));
378  nullsPtr = (bool *) palloc(nitems * sizeof(bool));
379  ReadArrayStr(p, string,
380  nitems, ndim, dim,
381  &my_extra->proc, typioparam, typmod,
382  typdelim,
383  typlen, typbyval, typalign,
384  dataPtr, nullsPtr,
385  &hasnulls, &nbytes);
386  if (hasnulls)
387  {
388  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
389  nbytes += dataoffset;
390  }
391  else
392  {
393  dataoffset = 0; /* marker for no null bitmap */
394  nbytes += ARR_OVERHEAD_NONULLS(ndim);
395  }
396  retval = (ArrayType *) palloc0(nbytes);
397  SET_VARSIZE(retval, nbytes);
398  retval->ndim = ndim;
399  retval->dataoffset = dataoffset;
400 
401  /*
402  * This comes from the array's pg_type.typelem (which points to the base
403  * data type's pg_type.oid) and stores system oids in user tables. This
404  * oid must be preserved by binary upgrades.
405  */
406  retval->elemtype = element_type;
407  memcpy(ARR_DIMS(retval), dim, ndim * sizeof(int));
408  memcpy(ARR_LBOUND(retval), lBound, ndim * sizeof(int));
409 
410  CopyArrayEls(retval,
411  dataPtr, nullsPtr, nitems,
412  typlen, typbyval, typalign,
413  true);
414 
415  pfree(dataPtr);
416  pfree(nullsPtr);
417  pfree(string_save);
418 
419  PG_RETURN_ARRAYTYPE_P(retval);
420 }
421 
422 /*
423  * array_isspace() --- a non-locale-dependent isspace()
424  *
425  * We used to use isspace() for parsing array values, but that has
426  * undesirable results: an array value might be silently interpreted
427  * differently depending on the locale setting. Now we just hard-wire
428  * the traditional ASCII definition of isspace().
429  */
430 static bool
431 array_isspace(char ch)
432 {
433  if (ch == ' ' ||
434  ch == '\t' ||
435  ch == '\n' ||
436  ch == '\r' ||
437  ch == '\v' ||
438  ch == '\f')
439  return true;
440  return false;
441 }
442 
443 /*
444  * ArrayCount
445  * Determines the dimensions for an array string.
446  *
447  * Returns number of dimensions as function result. The axis lengths are
448  * returned in dim[], which must be of size MAXDIM.
449  */
450 static int
451 ArrayCount(const char *str, int *dim, char typdelim)
452 {
453  int nest_level = 0,
454  i;
455  int ndim = 1,
456  temp[MAXDIM],
457  nelems[MAXDIM],
458  nelems_last[MAXDIM];
459  bool in_quotes = false;
460  bool eoArray = false;
461  bool empty_array = true;
462  const char *ptr;
463  ArrayParseState parse_state = ARRAY_NO_LEVEL;
464 
465  for (i = 0; i < MAXDIM; ++i)
466  {
467  temp[i] = dim[i] = nelems_last[i] = 0;
468  nelems[i] = 1;
469  }
470 
471  ptr = str;
472  while (!eoArray)
473  {
474  bool itemdone = false;
475 
476  while (!itemdone)
477  {
478  if (parse_state == ARRAY_ELEM_STARTED ||
479  parse_state == ARRAY_QUOTED_ELEM_STARTED)
480  empty_array = false;
481 
482  switch (*ptr)
483  {
484  case '\0':
485  /* Signal a premature end of the string */
486  ereport(ERROR,
487  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
488  errmsg("malformed array literal: \"%s\"", str),
489  errdetail("Unexpected end of input.")));
490  break;
491  case '\\':
492 
493  /*
494  * An escape must be after a level start, after an element
495  * start, or after an element delimiter. In any case we
496  * now must be past an element start.
497  */
498  if (parse_state != ARRAY_LEVEL_STARTED &&
499  parse_state != ARRAY_ELEM_STARTED &&
500  parse_state != ARRAY_QUOTED_ELEM_STARTED &&
501  parse_state != ARRAY_ELEM_DELIMITED)
502  ereport(ERROR,
503  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
504  errmsg("malformed array literal: \"%s\"", str),
505  errdetail("Unexpected \"%c\" character.",
506  '\\')));
507  if (parse_state != ARRAY_QUOTED_ELEM_STARTED)
508  parse_state = ARRAY_ELEM_STARTED;
509  /* skip the escaped character */
510  if (*(ptr + 1))
511  ptr++;
512  else
513  ereport(ERROR,
514  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
515  errmsg("malformed array literal: \"%s\"", str),
516  errdetail("Unexpected end of input.")));
517  break;
518  case '\"':
519 
520  /*
521  * A quote must be after a level start, after a quoted
522  * element start, or after an element delimiter. In any
523  * case we now must be past an element start.
524  */
525  if (parse_state != ARRAY_LEVEL_STARTED &&
526  parse_state != ARRAY_QUOTED_ELEM_STARTED &&
527  parse_state != ARRAY_ELEM_DELIMITED)
528  ereport(ERROR,
529  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
530  errmsg("malformed array literal: \"%s\"", str),
531  errdetail("Unexpected array element.")));
532  in_quotes = !in_quotes;
533  if (in_quotes)
534  parse_state = ARRAY_QUOTED_ELEM_STARTED;
535  else
536  parse_state = ARRAY_QUOTED_ELEM_COMPLETED;
537  break;
538  case '{':
539  if (!in_quotes)
540  {
541  /*
542  * A left brace can occur if no nesting has occurred
543  * yet, after a level start, or after a level
544  * delimiter.
545  */
546  if (parse_state != ARRAY_NO_LEVEL &&
547  parse_state != ARRAY_LEVEL_STARTED &&
548  parse_state != ARRAY_LEVEL_DELIMITED)
549  ereport(ERROR,
550  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
551  errmsg("malformed array literal: \"%s\"", str),
552  errdetail("Unexpected \"%c\" character.",
553  '{')));
554  parse_state = ARRAY_LEVEL_STARTED;
555  if (nest_level >= MAXDIM)
556  ereport(ERROR,
557  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
558  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
559  nest_level + 1, MAXDIM)));
560  temp[nest_level] = 0;
561  nest_level++;
562  if (ndim < nest_level)
563  ndim = nest_level;
564  }
565  break;
566  case '}':
567  if (!in_quotes)
568  {
569  /*
570  * A right brace can occur after an element start, an
571  * element completion, a quoted element completion, or
572  * a level completion.
573  */
574  if (parse_state != ARRAY_ELEM_STARTED &&
575  parse_state != ARRAY_ELEM_COMPLETED &&
576  parse_state != ARRAY_QUOTED_ELEM_COMPLETED &&
577  parse_state != ARRAY_LEVEL_COMPLETED &&
578  !(nest_level == 1 && parse_state == ARRAY_LEVEL_STARTED))
579  ereport(ERROR,
580  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
581  errmsg("malformed array literal: \"%s\"", str),
582  errdetail("Unexpected \"%c\" character.",
583  '}')));
584  parse_state = ARRAY_LEVEL_COMPLETED;
585  if (nest_level == 0)
586  ereport(ERROR,
587  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
588  errmsg("malformed array literal: \"%s\"", str),
589  errdetail("Unmatched \"%c\" character.", '}')));
590  nest_level--;
591 
592  if (nelems_last[nest_level] != 0 &&
593  nelems[nest_level] != nelems_last[nest_level])
594  ereport(ERROR,
595  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
596  errmsg("malformed array literal: \"%s\"", str),
597  errdetail("Multidimensional arrays must have "
598  "sub-arrays with matching "
599  "dimensions.")));
600  nelems_last[nest_level] = nelems[nest_level];
601  nelems[nest_level] = 1;
602  if (nest_level == 0)
603  eoArray = itemdone = true;
604  else
605  {
606  /*
607  * We don't set itemdone here; see comments in
608  * ReadArrayStr
609  */
610  temp[nest_level - 1]++;
611  }
612  }
613  break;
614  default:
615  if (!in_quotes)
616  {
617  if (*ptr == typdelim)
618  {
619  /*
620  * Delimiters can occur after an element start, an
621  * element completion, a quoted element
622  * completion, or a level completion.
623  */
624  if (parse_state != ARRAY_ELEM_STARTED &&
625  parse_state != ARRAY_ELEM_COMPLETED &&
626  parse_state != ARRAY_QUOTED_ELEM_COMPLETED &&
627  parse_state != ARRAY_LEVEL_COMPLETED)
628  ereport(ERROR,
629  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
630  errmsg("malformed array literal: \"%s\"", str),
631  errdetail("Unexpected \"%c\" character.",
632  typdelim)));
633  if (parse_state == ARRAY_LEVEL_COMPLETED)
634  parse_state = ARRAY_LEVEL_DELIMITED;
635  else
636  parse_state = ARRAY_ELEM_DELIMITED;
637  itemdone = true;
638  nelems[nest_level - 1]++;
639  }
640  else if (!array_isspace(*ptr))
641  {
642  /*
643  * Other non-space characters must be after a
644  * level start, after an element start, or after
645  * an element delimiter. In any case we now must
646  * be past an element start.
647  */
648  if (parse_state != ARRAY_LEVEL_STARTED &&
649  parse_state != ARRAY_ELEM_STARTED &&
650  parse_state != ARRAY_ELEM_DELIMITED)
651  ereport(ERROR,
652  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
653  errmsg("malformed array literal: \"%s\"", str),
654  errdetail("Unexpected array element.")));
655  parse_state = ARRAY_ELEM_STARTED;
656  }
657  }
658  break;
659  }
660  if (!itemdone)
661  ptr++;
662  }
663  temp[ndim - 1]++;
664  ptr++;
665  }
666 
667  /* only whitespace is allowed after the closing brace */
668  while (*ptr)
669  {
670  if (!array_isspace(*ptr++))
671  ereport(ERROR,
672  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
673  errmsg("malformed array literal: \"%s\"", str),
674  errdetail("Junk after closing right brace.")));
675  }
676 
677  /* special case for an empty array */
678  if (empty_array)
679  return 0;
680 
681  for (i = 0; i < ndim; ++i)
682  dim[i] = temp[i];
683 
684  return ndim;
685 }
686 
687 /*
688  * ReadArrayStr :
689  * parses the array string pointed to by "arrayStr" and converts the values
690  * to internal format. Unspecified elements are initialized to nulls.
691  * The array dimensions must already have been determined.
692  *
693  * Inputs:
694  * arrayStr: the string to parse.
695  * CAUTION: the contents of "arrayStr" will be modified!
696  * origStr: the unmodified input string, used only in error messages.
697  * nitems: total number of array elements, as already determined.
698  * ndim: number of array dimensions
699  * dim[]: array axis lengths
700  * inputproc: type-specific input procedure for element datatype.
701  * typioparam, typmod: auxiliary values to pass to inputproc.
702  * typdelim: the value delimiter (type-specific).
703  * typlen, typbyval, typalign: storage parameters of element datatype.
704  *
705  * Outputs:
706  * values[]: filled with converted data values.
707  * nulls[]: filled with is-null markers.
708  * *hasnulls: set TRUE iff there are any null elements.
709  * *nbytes: set to total size of data area needed (including alignment
710  * padding but not including array header overhead).
711  *
712  * Note that values[] and nulls[] are allocated by the caller, and must have
713  * nitems elements.
714  */
715 static void
716 ReadArrayStr(char *arrayStr,
717  const char *origStr,
718  int nitems,
719  int ndim,
720  int *dim,
721  FmgrInfo *inputproc,
722  Oid typioparam,
723  int32 typmod,
724  char typdelim,
725  int typlen,
726  bool typbyval,
727  char typalign,
728  Datum *values,
729  bool *nulls,
730  bool *hasnulls,
731  int32 *nbytes)
732 {
733  int i,
734  nest_level = 0;
735  char *srcptr;
736  bool in_quotes = false;
737  bool eoArray = false;
738  bool hasnull;
739  int32 totbytes;
740  int indx[MAXDIM],
741  prod[MAXDIM];
742 
743  mda_get_prod(ndim, dim, prod);
744  MemSet(indx, 0, sizeof(indx));
745 
746  /* Initialize is-null markers to true */
747  memset(nulls, true, nitems * sizeof(bool));
748 
749  /*
750  * We have to remove " and \ characters to create a clean item value to
751  * pass to the datatype input routine. We overwrite each item value
752  * in-place within arrayStr to do this. srcptr is the current scan point,
753  * and dstptr is where we are copying to.
754  *
755  * We also want to suppress leading and trailing unquoted whitespace. We
756  * use the leadingspace flag to suppress leading space. Trailing space is
757  * tracked by using dstendptr to point to the last significant output
758  * character.
759  *
760  * The error checking in this routine is mostly pro-forma, since we expect
761  * that ArrayCount() already validated the string. So we don't bother
762  * with errdetail messages.
763  */
764  srcptr = arrayStr;
765  while (!eoArray)
766  {
767  bool itemdone = false;
768  bool leadingspace = true;
769  bool hasquoting = false;
770  char *itemstart;
771  char *dstptr;
772  char *dstendptr;
773 
774  i = -1;
775  itemstart = dstptr = dstendptr = srcptr;
776 
777  while (!itemdone)
778  {
779  switch (*srcptr)
780  {
781  case '\0':
782  /* Signal a premature end of the string */
783  ereport(ERROR,
784  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
785  errmsg("malformed array literal: \"%s\"",
786  origStr)));
787  break;
788  case '\\':
789  /* Skip backslash, copy next character as-is. */
790  srcptr++;
791  if (*srcptr == '\0')
792  ereport(ERROR,
793  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
794  errmsg("malformed array literal: \"%s\"",
795  origStr)));
796  *dstptr++ = *srcptr++;
797  /* Treat the escaped character as non-whitespace */
798  leadingspace = false;
799  dstendptr = dstptr;
800  hasquoting = true; /* can't be a NULL marker */
801  break;
802  case '\"':
803  in_quotes = !in_quotes;
804  if (in_quotes)
805  leadingspace = false;
806  else
807  {
808  /*
809  * Advance dstendptr when we exit in_quotes; this
810  * saves having to do it in all the other in_quotes
811  * cases.
812  */
813  dstendptr = dstptr;
814  }
815  hasquoting = true; /* can't be a NULL marker */
816  srcptr++;
817  break;
818  case '{':
819  if (!in_quotes)
820  {
821  if (nest_level >= ndim)
822  ereport(ERROR,
823  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
824  errmsg("malformed array literal: \"%s\"",
825  origStr)));
826  nest_level++;
827  indx[nest_level - 1] = 0;
828  srcptr++;
829  }
830  else
831  *dstptr++ = *srcptr++;
832  break;
833  case '}':
834  if (!in_quotes)
835  {
836  if (nest_level == 0)
837  ereport(ERROR,
838  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
839  errmsg("malformed array literal: \"%s\"",
840  origStr)));
841  if (i == -1)
842  i = ArrayGetOffset0(ndim, indx, prod);
843  indx[nest_level - 1] = 0;
844  nest_level--;
845  if (nest_level == 0)
846  eoArray = itemdone = true;
847  else
848  indx[nest_level - 1]++;
849  srcptr++;
850  }
851  else
852  *dstptr++ = *srcptr++;
853  break;
854  default:
855  if (in_quotes)
856  *dstptr++ = *srcptr++;
857  else if (*srcptr == typdelim)
858  {
859  if (i == -1)
860  i = ArrayGetOffset0(ndim, indx, prod);
861  itemdone = true;
862  indx[ndim - 1]++;
863  srcptr++;
864  }
865  else if (array_isspace(*srcptr))
866  {
867  /*
868  * If leading space, drop it immediately. Else, copy
869  * but don't advance dstendptr.
870  */
871  if (leadingspace)
872  srcptr++;
873  else
874  *dstptr++ = *srcptr++;
875  }
876  else
877  {
878  *dstptr++ = *srcptr++;
879  leadingspace = false;
880  dstendptr = dstptr;
881  }
882  break;
883  }
884  }
885 
886  Assert(dstptr < srcptr);
887  *dstendptr = '\0';
888 
889  if (i < 0 || i >= nitems)
890  ereport(ERROR,
891  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
892  errmsg("malformed array literal: \"%s\"",
893  origStr)));
894 
895  if (Array_nulls && !hasquoting &&
896  pg_strcasecmp(itemstart, "NULL") == 0)
897  {
898  /* it's a NULL item */
899  values[i] = InputFunctionCall(inputproc, NULL,
900  typioparam, typmod);
901  nulls[i] = true;
902  }
903  else
904  {
905  values[i] = InputFunctionCall(inputproc, itemstart,
906  typioparam, typmod);
907  nulls[i] = false;
908  }
909  }
910 
911  /*
912  * Check for nulls, compute total data space needed
913  */
914  hasnull = false;
915  totbytes = 0;
916  for (i = 0; i < nitems; i++)
917  {
918  if (nulls[i])
919  hasnull = true;
920  else
921  {
922  /* let's just make sure data is not toasted */
923  if (typlen == -1)
924  values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
925  totbytes = att_addlength_datum(totbytes, typlen, values[i]);
926  totbytes = att_align_nominal(totbytes, typalign);
927  /* check for overflow of total request */
928  if (!AllocSizeIsValid(totbytes))
929  ereport(ERROR,
930  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
931  errmsg("array size exceeds the maximum allowed (%d)",
932  (int) MaxAllocSize)));
933  }
934  }
935  *hasnulls = hasnull;
936  *nbytes = totbytes;
937 }
938 
939 
940 /*
941  * Copy data into an array object from a temporary array of Datums.
942  *
943  * array: array object (with header fields already filled in)
944  * values: array of Datums to be copied
945  * nulls: array of is-null flags (can be NULL if no nulls)
946  * nitems: number of Datums to be copied
947  * typbyval, typlen, typalign: info about element datatype
948  * freedata: if TRUE and element type is pass-by-ref, pfree data values
949  * referenced by Datums after copying them.
950  *
951  * If the input data is of varlena type, the caller must have ensured that
952  * the values are not toasted. (Doing it here doesn't work since the
953  * caller has already allocated space for the array...)
954  */
955 void
956 CopyArrayEls(ArrayType *array,
957  Datum *values,
958  bool *nulls,
959  int nitems,
960  int typlen,
961  bool typbyval,
962  char typalign,
963  bool freedata)
964 {
965  char *p = ARR_DATA_PTR(array);
966  bits8 *bitmap = ARR_NULLBITMAP(array);
967  int bitval = 0;
968  int bitmask = 1;
969  int i;
970 
971  if (typbyval)
972  freedata = false;
973 
974  for (i = 0; i < nitems; i++)
975  {
976  if (nulls && nulls[i])
977  {
978  if (!bitmap) /* shouldn't happen */
979  elog(ERROR, "null array element where not supported");
980  /* bitmap bit stays 0 */
981  }
982  else
983  {
984  bitval |= bitmask;
985  p += ArrayCastAndSet(values[i], typlen, typbyval, typalign, p);
986  if (freedata)
987  pfree(DatumGetPointer(values[i]));
988  }
989  if (bitmap)
990  {
991  bitmask <<= 1;
992  if (bitmask == 0x100)
993  {
994  *bitmap++ = bitval;
995  bitval = 0;
996  bitmask = 1;
997  }
998  }
999  }
1000 
1001  if (bitmap && bitmask != 1)
1002  *bitmap = bitval;
1003 }
1004 
1005 /*
1006  * array_out :
1007  * takes the internal representation of an array and returns a string
1008  * containing the array in its external format.
1009  */
1010 Datum
1011 array_out(PG_FUNCTION_ARGS)
1012 {
1013  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
1014  Oid element_type = AARR_ELEMTYPE(v);
1015  int typlen;
1016  bool typbyval;
1017  char typalign;
1018  char typdelim;
1019  char *p,
1020  *tmp,
1021  *retval,
1022  **values,
1023  dims_str[(MAXDIM * 33) + 2];
1024 
1025  /*
1026  * 33 per dim since we assume 15 digits per number + ':' +'[]'
1027  *
1028  * +2 allows for assignment operator + trailing null
1029  */
1030  bool *needquotes,
1031  needdims = false;
1032  int nitems,
1033  overall_length,
1034  i,
1035  j,
1036  k,
1037  indx[MAXDIM];
1038  int ndim,
1039  *dims,
1040  *lb;
1041  array_iter iter;
1042  ArrayMetaState *my_extra;
1043 
1044  /*
1045  * We arrange to look up info about element type, including its output
1046  * conversion proc, only once per series of calls, assuming the element
1047  * type doesn't change underneath us.
1048  */
1049  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
1050  if (my_extra == NULL)
1051  {
1052  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
1053  sizeof(ArrayMetaState));
1054  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
1055  my_extra->element_type = ~element_type;
1056  }
1057 
1058  if (my_extra->element_type != element_type)
1059  {
1060  /*
1061  * Get info about element type, including its output conversion proc
1062  */
1063  get_type_io_data(element_type, IOFunc_output,
1064  &my_extra->typlen, &my_extra->typbyval,
1065  &my_extra->typalign, &my_extra->typdelim,
1066  &my_extra->typioparam, &my_extra->typiofunc);
1067  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
1068  fcinfo->flinfo->fn_mcxt);
1069  my_extra->element_type = element_type;
1070  }
1071  typlen = my_extra->typlen;
1072  typbyval = my_extra->typbyval;
1073  typalign = my_extra->typalign;
1074  typdelim = my_extra->typdelim;
1075 
1076  ndim = AARR_NDIM(v);
1077  dims = AARR_DIMS(v);
1078  lb = AARR_LBOUND(v);
1079  nitems = ArrayGetNItems(ndim, dims);
1080 
1081  if (nitems == 0)
1082  {
1083  retval = pstrdup("{}");
1084  PG_RETURN_CSTRING(retval);
1085  }
1086 
1087  /*
1088  * we will need to add explicit dimensions if any dimension has a lower
1089  * bound other than one
1090  */
1091  for (i = 0; i < ndim; i++)
1092  {
1093  if (lb[i] != 1)
1094  {
1095  needdims = true;
1096  break;
1097  }
1098  }
1099 
1100  /*
1101  * Convert all values to string form, count total space needed (including
1102  * any overhead such as escaping backslashes), and detect whether each
1103  * item needs double quotes.
1104  */
1105  values = (char **) palloc(nitems * sizeof(char *));
1106  needquotes = (bool *) palloc(nitems * sizeof(bool));
1107  overall_length = 1; /* don't forget to count \0 at end. */
1108 
1109  array_iter_setup(&iter, v);
1110 
1111  for (i = 0; i < nitems; i++)
1112  {
1113  Datum itemvalue;
1114  bool isnull;
1115  bool needquote;
1116 
1117  /* Get source element, checking for NULL */
1118  itemvalue = array_iter_next(&iter, &isnull, i,
1119  typlen, typbyval, typalign);
1120 
1121  if (isnull)
1122  {
1123  values[i] = pstrdup("NULL");
1124  overall_length += 4;
1125  needquote = false;
1126  }
1127  else
1128  {
1129  values[i] = OutputFunctionCall(&my_extra->proc, itemvalue);
1130 
1131  /* count data plus backslashes; detect chars needing quotes */
1132  if (values[i][0] == '\0')
1133  needquote = true; /* force quotes for empty string */
1134  else if (pg_strcasecmp(values[i], "NULL") == 0)
1135  needquote = true; /* force quotes for literal NULL */
1136  else
1137  needquote = false;
1138 
1139  for (tmp = values[i]; *tmp != '\0'; tmp++)
1140  {
1141  char ch = *tmp;
1142 
1143  overall_length += 1;
1144  if (ch == '"' || ch == '\\')
1145  {
1146  needquote = true;
1147  overall_length += 1;
1148  }
1149  else if (ch == '{' || ch == '}' || ch == typdelim ||
1150  array_isspace(ch))
1151  needquote = true;
1152  }
1153  }
1154 
1155  needquotes[i] = needquote;
1156 
1157  /* Count the pair of double quotes, if needed */
1158  if (needquote)
1159  overall_length += 2;
1160  /* and the comma */
1161  overall_length += 1;
1162  }
1163 
1164  /*
1165  * count total number of curly braces in output string
1166  */
1167  for (i = j = 0, k = 1; i < ndim; i++)
1168  k *= dims[i], j += k;
1169 
1170  dims_str[0] = '\0';
1171 
1172  /* add explicit dimensions if required */
1173  if (needdims)
1174  {
1175  char *ptr = dims_str;
1176 
1177  for (i = 0; i < ndim; i++)
1178  {
1179  sprintf(ptr, "[%d:%d]", lb[i], lb[i] + dims[i] - 1);
1180  ptr += strlen(ptr);
1181  }
1182  *ptr++ = *ASSGN;
1183  *ptr = '\0';
1184  }
1185 
1186  retval = (char *) palloc(strlen(dims_str) + overall_length + 2 * j);
1187  p = retval;
1188 
1189 #define APPENDSTR(str) (strcpy(p, (str)), p += strlen(p))
1190 #define APPENDCHAR(ch) (*p++ = (ch), *p = '\0')
1191 
1192  if (needdims)
1193  APPENDSTR(dims_str);
1194  APPENDCHAR('{');
1195  for (i = 0; i < ndim; i++)
1196  indx[i] = 0;
1197  j = 0;
1198  k = 0;
1199  do
1200  {
1201  for (i = j; i < ndim - 1; i++)
1202  APPENDCHAR('{');
1203 
1204  if (needquotes[k])
1205  {
1206  APPENDCHAR('"');
1207  for (tmp = values[k]; *tmp; tmp++)
1208  {
1209  char ch = *tmp;
1210 
1211  if (ch == '"' || ch == '\\')
1212  *p++ = '\\';
1213  *p++ = ch;
1214  }
1215  *p = '\0';
1216  APPENDCHAR('"');
1217  }
1218  else
1219  APPENDSTR(values[k]);
1220  pfree(values[k++]);
1221 
1222  for (i = ndim - 1; i >= 0; i--)
1223  {
1224  indx[i] = (indx[i] + 1) % dims[i];
1225  if (indx[i])
1226  {
1227  APPENDCHAR(typdelim);
1228  break;
1229  }
1230  else
1231  APPENDCHAR('}');
1232  }
1233  j = i;
1234  } while (j != -1);
1235 
1236 #undef APPENDSTR
1237 #undef APPENDCHAR
1238 
1239  pfree(values);
1240  pfree(needquotes);
1241 
1242  PG_RETURN_CSTRING(retval);
1243 }
1244 
1245 /*
1246  * array_recv :
1247  * converts an array from the external binary format to
1248  * its internal format.
1249  *
1250  * return value :
1251  * the internal representation of the input array
1252  */
1253 Datum
1254 array_recv(PG_FUNCTION_ARGS)
1255 {
1256  StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
1257  Oid spec_element_type = PG_GETARG_OID(1); /* type of an array
1258  * element */
1259  int32 typmod = PG_GETARG_INT32(2); /* typmod for array elements */
1260  Oid element_type;
1261  int typlen;
1262  bool typbyval;
1263  char typalign;
1264  Oid typioparam;
1265  int i,
1266  nitems;
1267  Datum *dataPtr;
1268  bool *nullsPtr;
1269  bool hasnulls;
1270  int32 nbytes;
1271  int32 dataoffset;
1272  ArrayType *retval;
1273  int ndim,
1274  flags,
1275  dim[MAXDIM],
1276  lBound[MAXDIM];
1277  ArrayMetaState *my_extra;
1278 
1279  /* Get the array header information */
1280  ndim = pq_getmsgint(buf, 4);
1281  if (ndim < 0) /* we do allow zero-dimension arrays */
1282  ereport(ERROR,
1283  (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1284  errmsg("invalid number of dimensions: %d", ndim)));
1285  if (ndim > MAXDIM)
1286  ereport(ERROR,
1287  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1288  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
1289  ndim, MAXDIM)));
1290 
1291  flags = pq_getmsgint(buf, 4);
1292  if (flags != 0 && flags != 1)
1293  ereport(ERROR,
1294  (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1295  errmsg("invalid array flags")));
1296 
1297  element_type = pq_getmsgint(buf, sizeof(Oid));
1298  if (element_type != spec_element_type)
1299  {
1300  /* XXX Can we allow taking the input element type in any cases? */
1301  ereport(ERROR,
1302  (errcode(ERRCODE_DATATYPE_MISMATCH),
1303  errmsg("wrong element type")));
1304  }
1305 
1306  for (i = 0; i < ndim; i++)
1307  {
1308  dim[i] = pq_getmsgint(buf, 4);
1309  lBound[i] = pq_getmsgint(buf, 4);
1310 
1311  /*
1312  * Check overflow of upper bound. (ArrayNItems() below checks that
1313  * dim[i] >= 0)
1314  */
1315  if (dim[i] != 0)
1316  {
1317  int ub = lBound[i] + dim[i] - 1;
1318 
1319  if (lBound[i] > ub)
1320  ereport(ERROR,
1321  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1322  errmsg("integer out of range")));
1323  }
1324  }
1325 
1326  /* This checks for overflow of array dimensions */
1327  nitems = ArrayGetNItems(ndim, dim);
1328 
1329  /*
1330  * We arrange to look up info about element type, including its receive
1331  * conversion proc, only once per series of calls, assuming the element
1332  * type doesn't change underneath us.
1333  */
1334  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
1335  if (my_extra == NULL)
1336  {
1337  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
1338  sizeof(ArrayMetaState));
1339  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
1340  my_extra->element_type = ~element_type;
1341  }
1342 
1343  if (my_extra->element_type != element_type)
1344  {
1345  /* Get info about element type, including its receive proc */
1346  get_type_io_data(element_type, IOFunc_receive,
1347  &my_extra->typlen, &my_extra->typbyval,
1348  &my_extra->typalign, &my_extra->typdelim,
1349  &my_extra->typioparam, &my_extra->typiofunc);
1350  if (!OidIsValid(my_extra->typiofunc))
1351  ereport(ERROR,
1352  (errcode(ERRCODE_UNDEFINED_FUNCTION),
1353  errmsg("no binary input function available for type %s",
1354  format_type_be(element_type))));
1355  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
1356  fcinfo->flinfo->fn_mcxt);
1357  my_extra->element_type = element_type;
1358  }
1359 
1360  if (nitems == 0)
1361  {
1362  /* Return empty array ... but not till we've validated element_type */
1363  PG_RETURN_ARRAYTYPE_P(construct_empty_array(element_type));
1364  }
1365 
1366  typlen = my_extra->typlen;
1367  typbyval = my_extra->typbyval;
1368  typalign = my_extra->typalign;
1369  typioparam = my_extra->typioparam;
1370 
1371  dataPtr = (Datum *) palloc(nitems * sizeof(Datum));
1372  nullsPtr = (bool *) palloc(nitems * sizeof(bool));
1373  ReadArrayBinary(buf, nitems,
1374  &my_extra->proc, typioparam, typmod,
1375  typlen, typbyval, typalign,
1376  dataPtr, nullsPtr,
1377  &hasnulls, &nbytes);
1378  if (hasnulls)
1379  {
1380  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
1381  nbytes += dataoffset;
1382  }
1383  else
1384  {
1385  dataoffset = 0; /* marker for no null bitmap */
1386  nbytes += ARR_OVERHEAD_NONULLS(ndim);
1387  }
1388  retval = (ArrayType *) palloc0(nbytes);
1389  SET_VARSIZE(retval, nbytes);
1390  retval->ndim = ndim;
1391  retval->dataoffset = dataoffset;
1392  retval->elemtype = element_type;
1393  memcpy(ARR_DIMS(retval), dim, ndim * sizeof(int));
1394  memcpy(ARR_LBOUND(retval), lBound, ndim * sizeof(int));
1395 
1396  CopyArrayEls(retval,
1397  dataPtr, nullsPtr, nitems,
1398  typlen, typbyval, typalign,
1399  true);
1400 
1401  pfree(dataPtr);
1402  pfree(nullsPtr);
1403 
1404  PG_RETURN_ARRAYTYPE_P(retval);
1405 }
1406 
1407 /*
1408  * ReadArrayBinary:
1409  * collect the data elements of an array being read in binary style.
1410  *
1411  * Inputs:
1412  * buf: the data buffer to read from.
1413  * nitems: total number of array elements (already read).
1414  * receiveproc: type-specific receive procedure for element datatype.
1415  * typioparam, typmod: auxiliary values to pass to receiveproc.
1416  * typlen, typbyval, typalign: storage parameters of element datatype.
1417  *
1418  * Outputs:
1419  * values[]: filled with converted data values.
1420  * nulls[]: filled with is-null markers.
1421  * *hasnulls: set TRUE iff there are any null elements.
1422  * *nbytes: set to total size of data area needed (including alignment
1423  * padding but not including array header overhead).
1424  *
1425  * Note that values[] and nulls[] are allocated by the caller, and must have
1426  * nitems elements.
1427  */
1428 static void
1429 ReadArrayBinary(StringInfo buf,
1430  int nitems,
1431  FmgrInfo *receiveproc,
1432  Oid typioparam,
1433  int32 typmod,
1434  int typlen,
1435  bool typbyval,
1436  char typalign,
1437  Datum *values,
1438  bool *nulls,
1439  bool *hasnulls,
1440  int32 *nbytes)
1441 {
1442  int i;
1443  bool hasnull;
1444  int32 totbytes;
1445 
1446  for (i = 0; i < nitems; i++)
1447  {
1448  int itemlen;
1449  StringInfoData elem_buf;
1450  char csave;
1451 
1452  /* Get and check the item length */
1453  itemlen = pq_getmsgint(buf, 4);
1454  if (itemlen < -1 || itemlen > (buf->len - buf->cursor))
1455  ereport(ERROR,
1456  (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1457  errmsg("insufficient data left in message")));
1458 
1459  if (itemlen == -1)
1460  {
1461  /* -1 length means NULL */
1462  values[i] = ReceiveFunctionCall(receiveproc, NULL,
1463  typioparam, typmod);
1464  nulls[i] = true;
1465  continue;
1466  }
1467 
1468  /*
1469  * Rather than copying data around, we just set up a phony StringInfo
1470  * pointing to the correct portion of the input buffer. We assume we
1471  * can scribble on the input buffer so as to maintain the convention
1472  * that StringInfos have a trailing null.
1473  */
1474  elem_buf.data = &buf->data[buf->cursor];
1475  elem_buf.maxlen = itemlen + 1;
1476  elem_buf.len = itemlen;
1477  elem_buf.cursor = 0;
1478 
1479  buf->cursor += itemlen;
1480 
1481  csave = buf->data[buf->cursor];
1482  buf->data[buf->cursor] = '\0';
1483 
1484  /* Now call the element's receiveproc */
1485  values[i] = ReceiveFunctionCall(receiveproc, &elem_buf,
1486  typioparam, typmod);
1487  nulls[i] = false;
1488 
1489  /* Trouble if it didn't eat the whole buffer */
1490  if (elem_buf.cursor != itemlen)
1491  ereport(ERROR,
1492  (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1493  errmsg("improper binary format in array element %d",
1494  i + 1)));
1495 
1496  buf->data[buf->cursor] = csave;
1497  }
1498 
1499  /*
1500  * Check for nulls, compute total data space needed
1501  */
1502  hasnull = false;
1503  totbytes = 0;
1504  for (i = 0; i < nitems; i++)
1505  {
1506  if (nulls[i])
1507  hasnull = true;
1508  else
1509  {
1510  /* let's just make sure data is not toasted */
1511  if (typlen == -1)
1512  values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
1513  totbytes = att_addlength_datum(totbytes, typlen, values[i]);
1514  totbytes = att_align_nominal(totbytes, typalign);
1515  /* check for overflow of total request */
1516  if (!AllocSizeIsValid(totbytes))
1517  ereport(ERROR,
1518  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1519  errmsg("array size exceeds the maximum allowed (%d)",
1520  (int) MaxAllocSize)));
1521  }
1522  }
1523  *hasnulls = hasnull;
1524  *nbytes = totbytes;
1525 }
1526 
1527 
1528 /*
1529  * array_send :
1530  * takes the internal representation of an array and returns a bytea
1531  * containing the array in its external binary format.
1532  */
1533 Datum
1534 array_send(PG_FUNCTION_ARGS)
1535 {
1536  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
1537  Oid element_type = AARR_ELEMTYPE(v);
1538  int typlen;
1539  bool typbyval;
1540  char typalign;
1541  int nitems,
1542  i;
1543  int ndim,
1544  *dim,
1545  *lb;
1546  StringInfoData buf;
1547  array_iter iter;
1548  ArrayMetaState *my_extra;
1549 
1550  /*
1551  * We arrange to look up info about element type, including its send
1552  * conversion proc, only once per series of calls, assuming the element
1553  * type doesn't change underneath us.
1554  */
1555  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
1556  if (my_extra == NULL)
1557  {
1558  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
1559  sizeof(ArrayMetaState));
1560  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
1561  my_extra->element_type = ~element_type;
1562  }
1563 
1564  if (my_extra->element_type != element_type)
1565  {
1566  /* Get info about element type, including its send proc */
1567  get_type_io_data(element_type, IOFunc_send,
1568  &my_extra->typlen, &my_extra->typbyval,
1569  &my_extra->typalign, &my_extra->typdelim,
1570  &my_extra->typioparam, &my_extra->typiofunc);
1571  if (!OidIsValid(my_extra->typiofunc))
1572  ereport(ERROR,
1573  (errcode(ERRCODE_UNDEFINED_FUNCTION),
1574  errmsg("no binary output function available for type %s",
1575  format_type_be(element_type))));
1576  fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
1577  fcinfo->flinfo->fn_mcxt);
1578  my_extra->element_type = element_type;
1579  }
1580  typlen = my_extra->typlen;
1581  typbyval = my_extra->typbyval;
1582  typalign = my_extra->typalign;
1583 
1584  ndim = AARR_NDIM(v);
1585  dim = AARR_DIMS(v);
1586  lb = AARR_LBOUND(v);
1587  nitems = ArrayGetNItems(ndim, dim);
1588 
1589  pq_begintypsend(&buf);
1590 
1591  /* Send the array header information */
1592  pq_sendint(&buf, ndim, 4);
1593  pq_sendint(&buf, AARR_HASNULL(v) ? 1 : 0, 4);
1594  pq_sendint(&buf, element_type, sizeof(Oid));
1595  for (i = 0; i < ndim; i++)
1596  {
1597  pq_sendint(&buf, dim[i], 4);
1598  pq_sendint(&buf, lb[i], 4);
1599  }
1600 
1601  /* Send the array elements using the element's own sendproc */
1602  array_iter_setup(&iter, v);
1603 
1604  for (i = 0; i < nitems; i++)
1605  {
1606  Datum itemvalue;
1607  bool isnull;
1608 
1609  /* Get source element, checking for NULL */
1610  itemvalue = array_iter_next(&iter, &isnull, i,
1611  typlen, typbyval, typalign);
1612 
1613  if (isnull)
1614  {
1615  /* -1 length means a NULL */
1616  pq_sendint(&buf, -1, 4);
1617  }
1618  else
1619  {
1620  bytea *outputbytes;
1621 
1622  outputbytes = SendFunctionCall(&my_extra->proc, itemvalue);
1623  pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
1624  pq_sendbytes(&buf, VARDATA(outputbytes),
1625  VARSIZE(outputbytes) - VARHDRSZ);
1626  pfree(outputbytes);
1627  }
1628  }
1629 
1630  PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
1631 }
1632 
1633 /*
1634  * array_ndims :
1635  * returns the number of dimensions of the array pointed to by "v"
1636  */
1637 Datum
1638 array_ndims(PG_FUNCTION_ARGS)
1639 {
1640  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
1641 
1642  /* Sanity check: does it look like an array at all? */
1643  if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
1644  PG_RETURN_NULL();
1645 
1646  PG_RETURN_INT32(AARR_NDIM(v));
1647 }
1648 
1649 /*
1650  * array_dims :
1651  * returns the dimensions of the array pointed to by "v", as a "text"
1652  */
1653 Datum
1654 array_dims(PG_FUNCTION_ARGS)
1655 {
1656  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
1657  char *p;
1658  int i;
1659  int *dimv,
1660  *lb;
1661 
1662  /*
1663  * 33 since we assume 15 digits per number + ':' +'[]'
1664  *
1665  * +1 for trailing null
1666  */
1667  char buf[MAXDIM * 33 + 1];
1668 
1669  /* Sanity check: does it look like an array at all? */
1670  if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
1671  PG_RETURN_NULL();
1672 
1673  dimv = AARR_DIMS(v);
1674  lb = AARR_LBOUND(v);
1675 
1676  p = buf;
1677  for (i = 0; i < AARR_NDIM(v); i++)
1678  {
1679  sprintf(p, "[%d:%d]", lb[i], dimv[i] + lb[i] - 1);
1680  p += strlen(p);
1681  }
1682 
1683  PG_RETURN_TEXT_P(cstring_to_text(buf));
1684 }
1685 
1686 /*
1687  * array_lower :
1688  * returns the lower dimension, of the DIM requested, for
1689  * the array pointed to by "v", as an int4
1690  */
1691 Datum
1692 array_lower(PG_FUNCTION_ARGS)
1693 {
1694  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
1695  int reqdim = PG_GETARG_INT32(1);
1696  int *lb;
1697  int result;
1698 
1699  /* Sanity check: does it look like an array at all? */
1700  if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
1701  PG_RETURN_NULL();
1702 
1703  /* Sanity check: was the requested dim valid */
1704  if (reqdim <= 0 || reqdim > AARR_NDIM(v))
1705  PG_RETURN_NULL();
1706 
1707  lb = AARR_LBOUND(v);
1708  result = lb[reqdim - 1];
1709 
1710  PG_RETURN_INT32(result);
1711 }
1712 
1713 /*
1714  * array_upper :
1715  * returns the upper dimension, of the DIM requested, for
1716  * the array pointed to by "v", as an int4
1717  */
1718 Datum
1719 array_upper(PG_FUNCTION_ARGS)
1720 {
1721  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
1722  int reqdim = PG_GETARG_INT32(1);
1723  int *dimv,
1724  *lb;
1725  int result;
1726 
1727  /* Sanity check: does it look like an array at all? */
1728  if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
1729  PG_RETURN_NULL();
1730 
1731  /* Sanity check: was the requested dim valid */
1732  if (reqdim <= 0 || reqdim > AARR_NDIM(v))
1733  PG_RETURN_NULL();
1734 
1735  lb = AARR_LBOUND(v);
1736  dimv = AARR_DIMS(v);
1737 
1738  result = dimv[reqdim - 1] + lb[reqdim - 1] - 1;
1739 
1740  PG_RETURN_INT32(result);
1741 }
1742 
1743 /*
1744  * array_length :
1745  * returns the length, of the dimension requested, for
1746  * the array pointed to by "v", as an int4
1747  */
1748 Datum
1749 array_length(PG_FUNCTION_ARGS)
1750 {
1751  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
1752  int reqdim = PG_GETARG_INT32(1);
1753  int *dimv;
1754  int result;
1755 
1756  /* Sanity check: does it look like an array at all? */
1757  if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
1758  PG_RETURN_NULL();
1759 
1760  /* Sanity check: was the requested dim valid */
1761  if (reqdim <= 0 || reqdim > AARR_NDIM(v))
1762  PG_RETURN_NULL();
1763 
1764  dimv = AARR_DIMS(v);
1765 
1766  result = dimv[reqdim - 1];
1767 
1768  PG_RETURN_INT32(result);
1769 }
1770 
1771 /*
1772  * array_cardinality:
1773  * returns the total number of elements in an array
1774  */
1775 Datum
1776 array_cardinality(PG_FUNCTION_ARGS)
1777 {
1778  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
1779 
1780  PG_RETURN_INT32(ArrayGetNItems(AARR_NDIM(v), AARR_DIMS(v)));
1781 }
1782 
1783 
1784 /*
1785  * array_get_element :
1786  * This routine takes an array datum and a subscript array and returns
1787  * the referenced item as a Datum. Note that for a pass-by-reference
1788  * datatype, the returned Datum is a pointer into the array object.
1789  *
1790  * This handles both ordinary varlena arrays and fixed-length arrays.
1791  *
1792  * Inputs:
1793  * arraydatum: the array object (mustn't be NULL)
1794  * nSubscripts: number of subscripts supplied
1795  * indx[]: the subscript values
1796  * arraytyplen: pg_type.typlen for the array type
1797  * elmlen: pg_type.typlen for the array's element type
1798  * elmbyval: pg_type.typbyval for the array's element type
1799  * elmalign: pg_type.typalign for the array's element type
1800  *
1801  * Outputs:
1802  * The return value is the element Datum.
1803  * *isNull is set to indicate whether the element is NULL.
1804  */
1805 Datum
1806 array_get_element(Datum arraydatum,
1807  int nSubscripts,
1808  int *indx,
1809  int arraytyplen,
1810  int elmlen,
1811  bool elmbyval,
1812  char elmalign,
1813  bool *isNull)
1814 {
1815  int i,
1816  ndim,
1817  *dim,
1818  *lb,
1819  offset,
1820  fixedDim[1],
1821  fixedLb[1];
1822  char *arraydataptr,
1823  *retptr;
1824  bits8 *arraynullsptr;
1825 
1826  if (arraytyplen > 0)
1827  {
1828  /*
1829  * fixed-length arrays -- these are assumed to be 1-d, 0-based
1830  */
1831  ndim = 1;
1832  fixedDim[0] = arraytyplen / elmlen;
1833  fixedLb[0] = 0;
1834  dim = fixedDim;
1835  lb = fixedLb;
1836  arraydataptr = (char *) DatumGetPointer(arraydatum);
1837  arraynullsptr = NULL;
1838  }
1839  else if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(arraydatum)))
1840  {
1841  /* expanded array: let's do this in a separate function */
1842  return array_get_element_expanded(arraydatum,
1843  nSubscripts,
1844  indx,
1845  arraytyplen,
1846  elmlen,
1847  elmbyval,
1848  elmalign,
1849  isNull);
1850  }
1851  else
1852  {
1853  /* detoast array if necessary, producing normal varlena input */
1854  ArrayType *array = DatumGetArrayTypeP(arraydatum);
1855 
1856  ndim = ARR_NDIM(array);
1857  dim = ARR_DIMS(array);
1858  lb = ARR_LBOUND(array);
1859  arraydataptr = ARR_DATA_PTR(array);
1860  arraynullsptr = ARR_NULLBITMAP(array);
1861  }
1862 
1863  /*
1864  * Return NULL for invalid subscript
1865  */
1866  if (ndim != nSubscripts || ndim <= 0 || ndim > MAXDIM)
1867  {
1868  *isNull = true;
1869  return (Datum) 0;
1870  }
1871  for (i = 0; i < ndim; i++)
1872  {
1873  if (indx[i] < lb[i] || indx[i] >= (dim[i] + lb[i]))
1874  {
1875  *isNull = true;
1876  return (Datum) 0;
1877  }
1878  }
1879 
1880  /*
1881  * Calculate the element number
1882  */
1883  offset = ArrayGetOffset(nSubscripts, dim, lb, indx);
1884 
1885  /*
1886  * Check for NULL array element
1887  */
1888  if (array_get_isnull(arraynullsptr, offset))
1889  {
1890  *isNull = true;
1891  return (Datum) 0;
1892  }
1893 
1894  /*
1895  * OK, get the element
1896  */
1897  *isNull = false;
1898  retptr = array_seek(arraydataptr, 0, arraynullsptr, offset,
1899  elmlen, elmbyval, elmalign);
1900  return ArrayCast(retptr, elmbyval, elmlen);
1901 }
1902 
1903 /*
1904  * Implementation of array_get_element() for an expanded array
1905  */
1906 static Datum
1907 array_get_element_expanded(Datum arraydatum,
1908  int nSubscripts, int *indx,
1909  int arraytyplen,
1910  int elmlen, bool elmbyval, char elmalign,
1911  bool *isNull)
1912 {
1913  ExpandedArrayHeader *eah;
1914  int i,
1915  ndim,
1916  *dim,
1917  *lb,
1918  offset;
1919  Datum *dvalues;
1920  bool *dnulls;
1921 
1922  eah = (ExpandedArrayHeader *) DatumGetEOHP(arraydatum);
1923  Assert(eah->ea_magic == EA_MAGIC);
1924 
1925  /* sanity-check caller's info against object */
1926  Assert(arraytyplen == -1);
1927  Assert(elmlen == eah->typlen);
1928  Assert(elmbyval == eah->typbyval);
1929  Assert(elmalign == eah->typalign);
1930 
1931  ndim = eah->ndims;
1932  dim = eah->dims;
1933  lb = eah->lbound;
1934 
1935  /*
1936  * Return NULL for invalid subscript
1937  */
1938  if (ndim != nSubscripts || ndim <= 0 || ndim > MAXDIM)
1939  {
1940  *isNull = true;
1941  return (Datum) 0;
1942  }
1943  for (i = 0; i < ndim; i++)
1944  {
1945  if (indx[i] < lb[i] || indx[i] >= (dim[i] + lb[i]))
1946  {
1947  *isNull = true;
1948  return (Datum) 0;
1949  }
1950  }
1951 
1952  /*
1953  * Calculate the element number
1954  */
1955  offset = ArrayGetOffset(nSubscripts, dim, lb, indx);
1956 
1957  /*
1958  * Deconstruct array if we didn't already. Note that we apply this even
1959  * if the input is nominally read-only: it should be safe enough.
1960  */
1961  deconstruct_expanded_array(eah);
1962 
1963  dvalues = eah->dvalues;
1964  dnulls = eah->dnulls;
1965 
1966  /*
1967  * Check for NULL array element
1968  */
1969  if (dnulls && dnulls[offset])
1970  {
1971  *isNull = true;
1972  return (Datum) 0;
1973  }
1974 
1975  /*
1976  * OK, get the element. It's OK to return a pass-by-ref value as a
1977  * pointer into the expanded array, for the same reason that regular
1978  * array_get_element can return a pointer into flat arrays: the value is
1979  * assumed not to change for as long as the Datum reference can exist.
1980  */
1981  *isNull = false;
1982  return dvalues[offset];
1983 }
1984 
1985 /*
1986  * array_get_slice :
1987  * This routine takes an array and a range of indices (upperIndex and
1988  * lowerIndx), creates a new array structure for the referred elements
1989  * and returns a pointer to it.
1990  *
1991  * This handles both ordinary varlena arrays and fixed-length arrays.
1992  *
1993  * Inputs:
1994  * arraydatum: the array object (mustn't be NULL)
1995  * nSubscripts: number of subscripts supplied (must be same for upper/lower)
1996  * upperIndx[]: the upper subscript values
1997  * lowerIndx[]: the lower subscript values
1998  * arraytyplen: pg_type.typlen for the array type
1999  * elmlen: pg_type.typlen for the array's element type
2000  * elmbyval: pg_type.typbyval for the array's element type
2001  * elmalign: pg_type.typalign for the array's element type
2002  *
2003  * Outputs:
2004  * The return value is the new array Datum (it's never NULL)
2005  *
2006  * NOTE: we assume it is OK to scribble on the provided subscript arrays
2007  * lowerIndx[] and upperIndx[]. These are generally just temporaries.
2008  */
2009 Datum
2010 array_get_slice(Datum arraydatum,
2011  int nSubscripts,
2012  int *upperIndx,
2013  int *lowerIndx,
2014  int arraytyplen,
2015  int elmlen,
2016  bool elmbyval,
2017  char elmalign)
2018 {
2019  ArrayType *array;
2020  ArrayType *newarray;
2021  int i,
2022  ndim,
2023  *dim,
2024  *lb,
2025  *newlb;
2026  int fixedDim[1],
2027  fixedLb[1];
2028  Oid elemtype;
2029  char *arraydataptr;
2030  bits8 *arraynullsptr;
2031  int32 dataoffset;
2032  int bytes,
2033  span[MAXDIM];
2034 
2035  if (arraytyplen > 0)
2036  {
2037  /*
2038  * fixed-length arrays -- currently, cannot slice these because parser
2039  * labels output as being of the fixed-length array type! Code below
2040  * shows how we could support it if the parser were changed to label
2041  * output as a suitable varlena array type.
2042  */
2043  ereport(ERROR,
2044  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2045  errmsg("slices of fixed-length arrays not implemented")));
2046 
2047  /*
2048  * fixed-length arrays -- these are assumed to be 1-d, 0-based
2049  *
2050  * XXX where would we get the correct ELEMTYPE from?
2051  */
2052  ndim = 1;
2053  fixedDim[0] = arraytyplen / elmlen;
2054  fixedLb[0] = 0;
2055  dim = fixedDim;
2056  lb = fixedLb;
2057  elemtype = InvalidOid; /* XXX */
2058  arraydataptr = (char *) DatumGetPointer(arraydatum);
2059  arraynullsptr = NULL;
2060  }
2061  else
2062  {
2063  /* detoast input array if necessary */
2064  array = DatumGetArrayTypeP(arraydatum);
2065 
2066  ndim = ARR_NDIM(array);
2067  dim = ARR_DIMS(array);
2068  lb = ARR_LBOUND(array);
2069  elemtype = ARR_ELEMTYPE(array);
2070  arraydataptr = ARR_DATA_PTR(array);
2071  arraynullsptr = ARR_NULLBITMAP(array);
2072  }
2073 
2074  /*
2075  * Check provided subscripts. A slice exceeding the current array limits
2076  * is silently truncated to the array limits. If we end up with an empty
2077  * slice, return an empty array.
2078  */
2079  if (ndim < nSubscripts || ndim <= 0 || ndim > MAXDIM)
2080  return PointerGetDatum(construct_empty_array(elemtype));
2081 
2082  for (i = 0; i < nSubscripts; i++)
2083  {
2084  if (lowerIndx[i] < lb[i])
2085  lowerIndx[i] = lb[i];
2086  if (upperIndx[i] >= (dim[i] + lb[i]))
2087  upperIndx[i] = dim[i] + lb[i] - 1;
2088  if (lowerIndx[i] > upperIndx[i])
2089  return PointerGetDatum(construct_empty_array(elemtype));
2090  }
2091  /* fill any missing subscript positions with full array range */
2092  for (; i < ndim; i++)
2093  {
2094  lowerIndx[i] = lb[i];
2095  upperIndx[i] = dim[i] + lb[i] - 1;
2096  if (lowerIndx[i] > upperIndx[i])
2097  return PointerGetDatum(construct_empty_array(elemtype));
2098  }
2099 
2100  mda_get_range(ndim, span, lowerIndx, upperIndx);
2101 
2102  bytes = array_slice_size(arraydataptr, arraynullsptr,
2103  ndim, dim, lb,
2104  lowerIndx, upperIndx,
2105  elmlen, elmbyval, elmalign);
2106 
2107  /*
2108  * Currently, we put a null bitmap in the result if the source has one;
2109  * could be smarter ...
2110  */
2111  if (arraynullsptr)
2112  {
2113  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, ArrayGetNItems(ndim, span));
2114  bytes += dataoffset;
2115  }
2116  else
2117  {
2118  dataoffset = 0; /* marker for no null bitmap */
2119  bytes += ARR_OVERHEAD_NONULLS(ndim);
2120  }
2121 
2122  newarray = (ArrayType *) palloc0(bytes);
2123  SET_VARSIZE(newarray, bytes);
2124  newarray->ndim = ndim;
2125  newarray->dataoffset = dataoffset;
2126  newarray->elemtype = elemtype;
2127  memcpy(ARR_DIMS(newarray), span, ndim * sizeof(int));
2128 
2129  /*
2130  * Lower bounds of the new array are set to 1. Formerly (before 7.3) we
2131  * copied the given lowerIndx values ... but that seems confusing.
2132  */
2133  newlb = ARR_LBOUND(newarray);
2134  for (i = 0; i < ndim; i++)
2135  newlb[i] = 1;
2136 
2137  array_extract_slice(newarray,
2138  ndim, dim, lb,
2139  arraydataptr, arraynullsptr,
2140  lowerIndx, upperIndx,
2141  elmlen, elmbyval, elmalign);
2142 
2143  return PointerGetDatum(newarray);
2144 }
2145 
2146 /*
2147  * array_set_element :
2148  * This routine sets the value of one array element (specified by
2149  * a subscript array) to a new value specified by "dataValue".
2150  *
2151  * This handles both ordinary varlena arrays and fixed-length arrays.
2152  *
2153  * Inputs:
2154  * arraydatum: the initial array object (mustn't be NULL)
2155  * nSubscripts: number of subscripts supplied
2156  * indx[]: the subscript values
2157  * dataValue: the datum to be inserted at the given position
2158  * isNull: whether dataValue is NULL
2159  * arraytyplen: pg_type.typlen for the array type
2160  * elmlen: pg_type.typlen for the array's element type
2161  * elmbyval: pg_type.typbyval for the array's element type
2162  * elmalign: pg_type.typalign for the array's element type
2163  *
2164  * Result:
2165  * A new array is returned, just like the old except for the one
2166  * modified entry. The original array object is not changed,
2167  * unless what is passed is a read-write reference to an expanded
2168  * array object; in that case the expanded array is updated in-place.
2169  *
2170  * For one-dimensional arrays only, we allow the array to be extended
2171  * by assigning to a position outside the existing subscript range; any
2172  * positions between the existing elements and the new one are set to NULLs.
2173  * (XXX TODO: allow a corresponding behavior for multidimensional arrays)
2174  *
2175  * NOTE: For assignments, we throw an error for invalid subscripts etc,
2176  * rather than returning a NULL as the fetch operations do.
2177  */
2178 Datum
2179 array_set_element(Datum arraydatum,
2180  int nSubscripts,
2181  int *indx,
2182  Datum dataValue,
2183  bool isNull,
2184  int arraytyplen,
2185  int elmlen,
2186  bool elmbyval,
2187  char elmalign)
2188 {
2189  ArrayType *array;
2190  ArrayType *newarray;
2191  int i,
2192  ndim,
2193  dim[MAXDIM],
2194  lb[MAXDIM],
2195  offset;
2196  char *elt_ptr;
2197  bool newhasnulls;
2198  bits8 *oldnullbitmap;
2199  int oldnitems,
2200  newnitems,
2201  olddatasize,
2202  newsize,
2203  olditemlen,
2204  newitemlen,
2205  overheadlen,
2206  oldoverheadlen,
2207  addedbefore,
2208  addedafter,
2209  lenbefore,
2210  lenafter;
2211 
2212  if (arraytyplen > 0)
2213  {
2214  /*
2215  * fixed-length arrays -- these are assumed to be 1-d, 0-based. We
2216  * cannot extend them, either.
2217  */
2218  char *resultarray;
2219 
2220  if (nSubscripts != 1)
2221  ereport(ERROR,
2222  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2223  errmsg("wrong number of array subscripts")));
2224 
2225  if (indx[0] < 0 || indx[0] * elmlen >= arraytyplen)
2226  ereport(ERROR,
2227  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2228  errmsg("array subscript out of range")));
2229 
2230  if (isNull)
2231  ereport(ERROR,
2232  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
2233  errmsg("cannot assign null value to an element of a fixed-length array")));
2234 
2235  resultarray = (char *) palloc(arraytyplen);
2236  memcpy(resultarray, DatumGetPointer(arraydatum), arraytyplen);
2237  elt_ptr = (char *) resultarray + indx[0] * elmlen;
2238  ArrayCastAndSet(dataValue, elmlen, elmbyval, elmalign, elt_ptr);
2239  return PointerGetDatum(resultarray);
2240  }
2241 
2242  if (nSubscripts <= 0 || nSubscripts > MAXDIM)
2243  ereport(ERROR,
2244  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2245  errmsg("wrong number of array subscripts")));
2246 
2247  /* make sure item to be inserted is not toasted */
2248  if (elmlen == -1 && !isNull)
2249  dataValue = PointerGetDatum(PG_DETOAST_DATUM(dataValue));
2250 
2251  if (VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(arraydatum)))
2252  {
2253  /* expanded array: let's do this in a separate function */
2254  return array_set_element_expanded(arraydatum,
2255  nSubscripts,
2256  indx,
2257  dataValue,
2258  isNull,
2259  arraytyplen,
2260  elmlen,
2261  elmbyval,
2262  elmalign);
2263  }
2264 
2265  /* detoast input array if necessary */
2266  array = DatumGetArrayTypeP(arraydatum);
2267 
2268  ndim = ARR_NDIM(array);
2269 
2270  /*
2271  * if number of dims is zero, i.e. an empty array, create an array with
2272  * nSubscripts dimensions, and set the lower bounds to the supplied
2273  * subscripts
2274  */
2275  if (ndim == 0)
2276  {
2277  Oid elmtype = ARR_ELEMTYPE(array);
2278 
2279  for (i = 0; i < nSubscripts; i++)
2280  {
2281  dim[i] = 1;
2282  lb[i] = indx[i];
2283  }
2284 
2285  return PointerGetDatum(construct_md_array(&dataValue, &isNull,
2286  nSubscripts, dim, lb,
2287  elmtype,
2288  elmlen, elmbyval, elmalign));
2289  }
2290 
2291  if (ndim != nSubscripts)
2292  ereport(ERROR,
2293  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2294  errmsg("wrong number of array subscripts")));
2295 
2296  /* copy dim/lb since we may modify them */
2297  memcpy(dim, ARR_DIMS(array), ndim * sizeof(int));
2298  memcpy(lb, ARR_LBOUND(array), ndim * sizeof(int));
2299 
2300  newhasnulls = (ARR_HASNULL(array) || isNull);
2301  addedbefore = addedafter = 0;
2302 
2303  /*
2304  * Check subscripts
2305  */
2306  if (ndim == 1)
2307  {
2308  if (indx[0] < lb[0])
2309  {
2310  addedbefore = lb[0] - indx[0];
2311  dim[0] += addedbefore;
2312  lb[0] = indx[0];
2313  if (addedbefore > 1)
2314  newhasnulls = true; /* will insert nulls */
2315  }
2316  if (indx[0] >= (dim[0] + lb[0]))
2317  {
2318  addedafter = indx[0] - (dim[0] + lb[0]) + 1;
2319  dim[0] += addedafter;
2320  if (addedafter > 1)
2321  newhasnulls = true; /* will insert nulls */
2322  }
2323  }
2324  else
2325  {
2326  /*
2327  * XXX currently we do not support extending multi-dimensional arrays
2328  * during assignment
2329  */
2330  for (i = 0; i < ndim; i++)
2331  {
2332  if (indx[i] < lb[i] ||
2333  indx[i] >= (dim[i] + lb[i]))
2334  ereport(ERROR,
2335  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2336  errmsg("array subscript out of range")));
2337  }
2338  }
2339 
2340  /*
2341  * Compute sizes of items and areas to copy
2342  */
2343  newnitems = ArrayGetNItems(ndim, dim);
2344  if (newhasnulls)
2345  overheadlen = ARR_OVERHEAD_WITHNULLS(ndim, newnitems);
2346  else
2347  overheadlen = ARR_OVERHEAD_NONULLS(ndim);
2348  oldnitems = ArrayGetNItems(ndim, ARR_DIMS(array));
2349  oldnullbitmap = ARR_NULLBITMAP(array);
2350  oldoverheadlen = ARR_DATA_OFFSET(array);
2351  olddatasize = ARR_SIZE(array) - oldoverheadlen;
2352  if (addedbefore)
2353  {
2354  offset = 0;
2355  lenbefore = 0;
2356  olditemlen = 0;
2357  lenafter = olddatasize;
2358  }
2359  else if (addedafter)
2360  {
2361  offset = oldnitems;
2362  lenbefore = olddatasize;
2363  olditemlen = 0;
2364  lenafter = 0;
2365  }
2366  else
2367  {
2368  offset = ArrayGetOffset(nSubscripts, dim, lb, indx);
2369  elt_ptr = array_seek(ARR_DATA_PTR(array), 0, oldnullbitmap, offset,
2370  elmlen, elmbyval, elmalign);
2371  lenbefore = (int) (elt_ptr - ARR_DATA_PTR(array));
2372  if (array_get_isnull(oldnullbitmap, offset))
2373  olditemlen = 0;
2374  else
2375  {
2376  olditemlen = att_addlength_pointer(0, elmlen, elt_ptr);
2377  olditemlen = att_align_nominal(olditemlen, elmalign);
2378  }
2379  lenafter = (int) (olddatasize - lenbefore - olditemlen);
2380  }
2381 
2382  if (isNull)
2383  newitemlen = 0;
2384  else
2385  {
2386  newitemlen = att_addlength_datum(0, elmlen, dataValue);
2387  newitemlen = att_align_nominal(newitemlen, elmalign);
2388  }
2389 
2390  newsize = overheadlen + lenbefore + newitemlen + lenafter;
2391 
2392  /*
2393  * OK, create the new array and fill in header/dimensions
2394  */
2395  newarray = (ArrayType *) palloc0(newsize);
2396  SET_VARSIZE(newarray, newsize);
2397  newarray->ndim = ndim;
2398  newarray->dataoffset = newhasnulls ? overheadlen : 0;
2399  newarray->elemtype = ARR_ELEMTYPE(array);
2400  memcpy(ARR_DIMS(newarray), dim, ndim * sizeof(int));
2401  memcpy(ARR_LBOUND(newarray), lb, ndim * sizeof(int));
2402 
2403  /*
2404  * Fill in data
2405  */
2406  memcpy((char *) newarray + overheadlen,
2407  (char *) array + oldoverheadlen,
2408  lenbefore);
2409  if (!isNull)
2410  ArrayCastAndSet(dataValue, elmlen, elmbyval, elmalign,
2411  (char *) newarray + overheadlen + lenbefore);
2412  memcpy((char *) newarray + overheadlen + lenbefore + newitemlen,
2413  (char *) array + oldoverheadlen + lenbefore + olditemlen,
2414  lenafter);
2415 
2416  /*
2417  * Fill in nulls bitmap if needed
2418  *
2419  * Note: it's possible we just replaced the last NULL with a non-NULL, and
2420  * could get rid of the bitmap. Seems not worth testing for though.
2421  */
2422  if (newhasnulls)
2423  {
2424  bits8 *newnullbitmap = ARR_NULLBITMAP(newarray);
2425 
2426  /* Zero the bitmap to take care of marking inserted positions null */
2427  MemSet(newnullbitmap, 0, (newnitems + 7) / 8);
2428  /* Fix the inserted value */
2429  if (addedafter)
2430  array_set_isnull(newnullbitmap, newnitems - 1, isNull);
2431  else
2432  array_set_isnull(newnullbitmap, offset, isNull);
2433  /* Fix the copied range(s) */
2434  if (addedbefore)
2435  array_bitmap_copy(newnullbitmap, addedbefore,
2436  oldnullbitmap, 0,
2437  oldnitems);
2438  else
2439  {
2440  array_bitmap_copy(newnullbitmap, 0,
2441  oldnullbitmap, 0,
2442  offset);
2443  if (addedafter == 0)
2444  array_bitmap_copy(newnullbitmap, offset + 1,
2445  oldnullbitmap, offset + 1,
2446  oldnitems - offset - 1);
2447  }
2448  }
2449 
2450  return PointerGetDatum(newarray);
2451 }
2452 
2453 /*
2454  * Implementation of array_set_element() for an expanded array
2455  *
2456  * Note: as with any operation on a read/write expanded object, we must
2457  * take pains not to leave the object in a corrupt state if we fail partway
2458  * through.
2459  */
2460 static Datum
2461 array_set_element_expanded(Datum arraydatum,
2462  int nSubscripts, int *indx,
2463  Datum dataValue, bool isNull,
2464  int arraytyplen,
2465  int elmlen, bool elmbyval, char elmalign)
2466 {
2467  ExpandedArrayHeader *eah;
2468  Datum *dvalues;
2469  bool *dnulls;
2470  int i,
2471  ndim,
2472  dim[MAXDIM],
2473  lb[MAXDIM],
2474  offset;
2475  bool dimschanged,
2476  newhasnulls;
2477  int addedbefore,
2478  addedafter;
2479  char *oldValue;
2480 
2481  /* Convert to R/W object if not so already */
2482  eah = DatumGetExpandedArray(arraydatum);
2483 
2484  /* Sanity-check caller's info against object; we don't use it otherwise */
2485  Assert(arraytyplen == -1);
2486  Assert(elmlen == eah->typlen);
2487  Assert(elmbyval == eah->typbyval);
2488  Assert(elmalign == eah->typalign);
2489 
2490  /*
2491  * Copy dimension info into local storage. This allows us to modify the
2492  * dimensions if needed, while not messing up the expanded value if we
2493  * fail partway through.
2494  */
2495  ndim = eah->ndims;
2496  Assert(ndim >= 0 && ndim <= MAXDIM);
2497  memcpy(dim, eah->dims, ndim * sizeof(int));
2498  memcpy(lb, eah->lbound, ndim * sizeof(int));
2499  dimschanged = false;
2500 
2501  /*
2502  * if number of dims is zero, i.e. an empty array, create an array with
2503  * nSubscripts dimensions, and set the lower bounds to the supplied
2504  * subscripts.
2505  */
2506  if (ndim == 0)
2507  {
2508  /*
2509  * Allocate adequate space for new dimension info. This is harmless
2510  * if we fail later.
2511  */
2512  Assert(nSubscripts > 0 && nSubscripts <= MAXDIM);
2513  eah->dims = (int *) MemoryContextAllocZero(eah->hdr.eoh_context,
2514  nSubscripts * sizeof(int));
2515  eah->lbound = (int *) MemoryContextAllocZero(eah->hdr.eoh_context,
2516  nSubscripts * sizeof(int));
2517 
2518  /* Update local copies of dimension info */
2519  ndim = nSubscripts;
2520  for (i = 0; i < nSubscripts; i++)
2521  {
2522  dim[i] = 0;
2523  lb[i] = indx[i];
2524  }
2525  dimschanged = true;
2526  }
2527  else if (ndim != nSubscripts)
2528  ereport(ERROR,
2529  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2530  errmsg("wrong number of array subscripts")));
2531 
2532  /*
2533  * Deconstruct array if we didn't already. (Someday maybe add a special
2534  * case path for fixed-length, no-nulls cases, where we can overwrite an
2535  * element in place without ever deconstructing. But today is not that
2536  * day.)
2537  */
2538  deconstruct_expanded_array(eah);
2539 
2540  /*
2541  * Copy new element into array's context, if needed (we assume it's
2542  * already detoasted, so no junk should be created). If we fail further
2543  * down, this memory is leaked, but that's reasonably harmless.
2544  */
2545  if (!eah->typbyval && !isNull)
2546  {
2547  MemoryContext oldcxt = MemoryContextSwitchTo(eah->hdr.eoh_context);
2548 
2549  dataValue = datumCopy(dataValue, false, eah->typlen);
2550  MemoryContextSwitchTo(oldcxt);
2551  }
2552 
2553  dvalues = eah->dvalues;
2554  dnulls = eah->dnulls;
2555 
2556  newhasnulls = ((dnulls != NULL) || isNull);
2557  addedbefore = addedafter = 0;
2558 
2559  /*
2560  * Check subscripts (this logic matches original array_set_element)
2561  */
2562  if (ndim == 1)
2563  {
2564  if (indx[0] < lb[0])
2565  {
2566  addedbefore = lb[0] - indx[0];
2567  dim[0] += addedbefore;
2568  lb[0] = indx[0];
2569  dimschanged = true;
2570  if (addedbefore > 1)
2571  newhasnulls = true; /* will insert nulls */
2572  }
2573  if (indx[0] >= (dim[0] + lb[0]))
2574  {
2575  addedafter = indx[0] - (dim[0] + lb[0]) + 1;
2576  dim[0] += addedafter;
2577  dimschanged = true;
2578  if (addedafter > 1)
2579  newhasnulls = true; /* will insert nulls */
2580  }
2581  }
2582  else
2583  {
2584  /*
2585  * XXX currently we do not support extending multi-dimensional arrays
2586  * during assignment
2587  */
2588  for (i = 0; i < ndim; i++)
2589  {
2590  if (indx[i] < lb[i] ||
2591  indx[i] >= (dim[i] + lb[i]))
2592  ereport(ERROR,
2593  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2594  errmsg("array subscript out of range")));
2595  }
2596  }
2597 
2598  /* Now we can calculate linear offset of target item in array */
2599  offset = ArrayGetOffset(nSubscripts, dim, lb, indx);
2600 
2601  /* Physically enlarge existing dvalues/dnulls arrays if needed */
2602  if (dim[0] > eah->dvalueslen)
2603  {
2604  /* We want some extra space if we're enlarging */
2605  int newlen = dim[0] + dim[0] / 8;
2606 
2607  newlen = Max(newlen, dim[0]); /* integer overflow guard */
2608  eah->dvalues = dvalues = (Datum *)
2609  repalloc(dvalues, newlen * sizeof(Datum));
2610  if (dnulls)
2611  eah->dnulls = dnulls = (bool *)
2612  repalloc(dnulls, newlen * sizeof(bool));
2613  eah->dvalueslen = newlen;
2614  }
2615 
2616  /*
2617  * If we need a nulls bitmap and don't already have one, create it, being
2618  * sure to mark all existing entries as not null.
2619  */
2620  if (newhasnulls && dnulls == NULL)
2621  eah->dnulls = dnulls = (bool *)
2622  MemoryContextAllocZero(eah->hdr.eoh_context,
2623  eah->dvalueslen * sizeof(bool));
2624 
2625  /*
2626  * We now have all the needed space allocated, so we're ready to make
2627  * irreversible changes. Be very wary of allowing failure below here.
2628  */
2629 
2630  /* Flattened value will no longer represent array accurately */
2631  eah->fvalue = NULL;
2632  /* And we don't know the flattened size either */
2633  eah->flat_size = 0;
2634 
2635  /* Update dimensionality info if needed */
2636  if (dimschanged)
2637  {
2638  eah->ndims = ndim;
2639  memcpy(eah->dims, dim, ndim * sizeof(int));
2640  memcpy(eah->lbound, lb, ndim * sizeof(int));
2641  }
2642 
2643  /* Reposition items if needed, and fill addedbefore items with nulls */
2644  if (addedbefore > 0)
2645  {
2646  memmove(dvalues + addedbefore, dvalues, eah->nelems * sizeof(Datum));
2647  for (i = 0; i < addedbefore; i++)
2648  dvalues[i] = (Datum) 0;
2649  if (dnulls)
2650  {
2651  memmove(dnulls + addedbefore, dnulls, eah->nelems * sizeof(bool));
2652  for (i = 0; i < addedbefore; i++)
2653  dnulls[i] = true;
2654  }
2655  eah->nelems += addedbefore;
2656  }
2657 
2658  /* fill addedafter items with nulls */
2659  if (addedafter > 0)
2660  {
2661  for (i = 0; i < addedafter; i++)
2662  dvalues[eah->nelems + i] = (Datum) 0;
2663  if (dnulls)
2664  {
2665  for (i = 0; i < addedafter; i++)
2666  dnulls[eah->nelems + i] = true;
2667  }
2668  eah->nelems += addedafter;
2669  }
2670 
2671  /* Grab old element value for pfree'ing, if needed. */
2672  if (!eah->typbyval && (dnulls == NULL || !dnulls[offset]))
2673  oldValue = (char *) DatumGetPointer(dvalues[offset]);
2674  else
2675  oldValue = NULL;
2676 
2677  /* And finally we can insert the new element. */
2678  dvalues[offset] = dataValue;
2679  if (dnulls)
2680  dnulls[offset] = isNull;
2681 
2682  /*
2683  * Free old element if needed; this keeps repeated element replacements
2684  * from bloating the array's storage. If the pfree somehow fails, it
2685  * won't corrupt the array.
2686  */
2687  if (oldValue)
2688  {
2689  /* Don't try to pfree a part of the original flat array */
2690  if (oldValue < eah->fstartptr || oldValue >= eah->fendptr)
2691  pfree(oldValue);
2692  }
2693 
2694  /* Done, return standard TOAST pointer for object */
2695  return EOHPGetRWDatum(&eah->hdr);
2696 }
2697 
2698 /*
2699  * array_set_slice :
2700  * This routine sets the value of a range of array locations (specified
2701  * by upper and lower subscript values) to new values passed as
2702  * another array.
2703  *
2704  * This handles both ordinary varlena arrays and fixed-length arrays.
2705  *
2706  * Inputs:
2707  * arraydatum: the initial array object (mustn't be NULL)
2708  * nSubscripts: number of subscripts supplied (must be same for upper/lower)
2709  * upperIndx[]: the upper subscript values
2710  * lowerIndx[]: the lower subscript values
2711  * srcArrayDatum: the source for the inserted values
2712  * isNull: indicates whether srcArrayDatum is NULL
2713  * arraytyplen: pg_type.typlen for the array type
2714  * elmlen: pg_type.typlen for the array's element type
2715  * elmbyval: pg_type.typbyval for the array's element type
2716  * elmalign: pg_type.typalign for the array's element type
2717  *
2718  * Result:
2719  * A new array is returned, just like the old except for the
2720  * modified range. The original array object is not changed.
2721  *
2722  * For one-dimensional arrays only, we allow the array to be extended
2723  * by assigning to positions outside the existing subscript range; any
2724  * positions between the existing elements and the new ones are set to NULLs.
2725  * (XXX TODO: allow a corresponding behavior for multidimensional arrays)
2726  *
2727  * NOTE: we assume it is OK to scribble on the provided index arrays
2728  * lowerIndx[] and upperIndx[]. These are generally just temporaries.
2729  *
2730  * NOTE: For assignments, we throw an error for silly subscripts etc,
2731  * rather than returning a NULL or empty array as the fetch operations do.
2732  */
2733 Datum
2734 array_set_slice(Datum arraydatum,
2735  int nSubscripts,
2736  int *upperIndx,
2737  int *lowerIndx,
2738  Datum srcArrayDatum,
2739  bool isNull,
2740  int arraytyplen,
2741  int elmlen,
2742  bool elmbyval,
2743  char elmalign)
2744 {
2745  ArrayType *array;
2746  ArrayType *srcArray;
2747  ArrayType *newarray;
2748  int i,
2749  ndim,
2750  dim[MAXDIM],
2751  lb[MAXDIM],
2752  span[MAXDIM];
2753  bool newhasnulls;
2754  int nitems,
2755  nsrcitems,
2756  olddatasize,
2757  newsize,
2758  olditemsize,
2759  newitemsize,
2760  overheadlen,
2761  oldoverheadlen,
2762  addedbefore,
2763  addedafter,
2764  lenbefore,
2765  lenafter,
2766  itemsbefore,
2767  itemsafter,
2768  nolditems;
2769 
2770  /* Currently, assignment from a NULL source array is a no-op */
2771  if (isNull)
2772  return arraydatum;
2773 
2774  if (arraytyplen > 0)
2775  {
2776  /*
2777  * fixed-length arrays -- not got round to doing this...
2778  */
2779  ereport(ERROR,
2780  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2781  errmsg("updates on slices of fixed-length arrays not implemented")));
2782  }
2783 
2784  /* detoast arrays if necessary */
2785  array = DatumGetArrayTypeP(arraydatum);
2786  srcArray = DatumGetArrayTypeP(srcArrayDatum);
2787 
2788  /* note: we assume srcArray contains no toasted elements */
2789 
2790  ndim = ARR_NDIM(array);
2791 
2792  /*
2793  * if number of dims is zero, i.e. an empty array, create an array with
2794  * nSubscripts dimensions, and set the upper and lower bounds to the
2795  * supplied subscripts
2796  */
2797  if (ndim == 0)
2798  {
2799  Datum *dvalues;
2800  bool *dnulls;
2801  int nelems;
2802  Oid elmtype = ARR_ELEMTYPE(array);
2803 
2804  deconstruct_array(srcArray, elmtype, elmlen, elmbyval, elmalign,
2805  &dvalues, &dnulls, &nelems);
2806 
2807  for (i = 0; i < nSubscripts; i++)
2808  {
2809  dim[i] = 1 + upperIndx[i] - lowerIndx[i];
2810  lb[i] = lowerIndx[i];
2811  }
2812 
2813  /* complain if too few source items; we ignore extras, however */
2814  if (nelems < ArrayGetNItems(nSubscripts, dim))
2815  ereport(ERROR,
2816  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2817  errmsg("source array too small")));
2818 
2819  return PointerGetDatum(construct_md_array(dvalues, dnulls, nSubscripts,
2820  dim, lb, elmtype,
2821  elmlen, elmbyval, elmalign));
2822  }
2823 
2824  if (ndim < nSubscripts || ndim <= 0 || ndim > MAXDIM)
2825  ereport(ERROR,
2826  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2827  errmsg("wrong number of array subscripts")));
2828 
2829  /* copy dim/lb since we may modify them */
2830  memcpy(dim, ARR_DIMS(array), ndim * sizeof(int));
2831  memcpy(lb, ARR_LBOUND(array), ndim * sizeof(int));
2832 
2833  newhasnulls = (ARR_HASNULL(array) || ARR_HASNULL(srcArray));
2834  addedbefore = addedafter = 0;
2835 
2836  /*
2837  * Check subscripts
2838  */
2839  if (ndim == 1)
2840  {
2841  Assert(nSubscripts == 1);
2842  if (lowerIndx[0] > upperIndx[0])
2843  ereport(ERROR,
2844  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2845  errmsg("upper bound cannot be less than lower bound")));
2846  if (lowerIndx[0] < lb[0])
2847  {
2848  if (upperIndx[0] < lb[0] - 1)
2849  newhasnulls = true; /* will insert nulls */
2850  addedbefore = lb[0] - lowerIndx[0];
2851  dim[0] += addedbefore;
2852  lb[0] = lowerIndx[0];
2853  }
2854  if (upperIndx[0] >= (dim[0] + lb[0]))
2855  {
2856  if (lowerIndx[0] > (dim[0] + lb[0]))
2857  newhasnulls = true; /* will insert nulls */
2858  addedafter = upperIndx[0] - (dim[0] + lb[0]) + 1;
2859  dim[0] += addedafter;
2860  }
2861  }
2862  else
2863  {
2864  /*
2865  * XXX currently we do not support extending multi-dimensional arrays
2866  * during assignment
2867  */
2868  for (i = 0; i < nSubscripts; i++)
2869  {
2870  if (lowerIndx[i] > upperIndx[i])
2871  ereport(ERROR,
2872  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2873  errmsg("upper bound cannot be less than lower bound")));
2874  if (lowerIndx[i] < lb[i] ||
2875  upperIndx[i] >= (dim[i] + lb[i]))
2876  ereport(ERROR,
2877  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2878  errmsg("array subscript out of range")));
2879  }
2880  /* fill any missing subscript positions with full array range */
2881  for (; i < ndim; i++)
2882  {
2883  lowerIndx[i] = lb[i];
2884  upperIndx[i] = dim[i] + lb[i] - 1;
2885  if (lowerIndx[i] > upperIndx[i])
2886  ereport(ERROR,
2887  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2888  errmsg("upper bound cannot be less than lower bound")));
2889  }
2890  }
2891 
2892  /* Do this mainly to check for overflow */
2893  nitems = ArrayGetNItems(ndim, dim);
2894 
2895  /*
2896  * Make sure source array has enough entries. Note we ignore the shape of
2897  * the source array and just read entries serially.
2898  */
2899  mda_get_range(ndim, span, lowerIndx, upperIndx);
2900  nsrcitems = ArrayGetNItems(ndim, span);
2901  if (nsrcitems > ArrayGetNItems(ARR_NDIM(srcArray), ARR_DIMS(srcArray)))
2902  ereport(ERROR,
2903  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2904  errmsg("source array too small")));
2905 
2906  /*
2907  * Compute space occupied by new entries, space occupied by replaced
2908  * entries, and required space for new array.
2909  */
2910  if (newhasnulls)
2911  overheadlen = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
2912  else
2913  overheadlen = ARR_OVERHEAD_NONULLS(ndim);
2914  newitemsize = array_nelems_size(ARR_DATA_PTR(srcArray), 0,
2915  ARR_NULLBITMAP(srcArray), nsrcitems,
2916  elmlen, elmbyval, elmalign);
2917  oldoverheadlen = ARR_DATA_OFFSET(array);
2918  olddatasize = ARR_SIZE(array) - oldoverheadlen;
2919  if (ndim > 1)
2920  {
2921  /*
2922  * here we do not need to cope with extension of the array; it would
2923  * be a lot more complicated if we had to do so...
2924  */
2925  olditemsize = array_slice_size(ARR_DATA_PTR(array),
2926  ARR_NULLBITMAP(array),
2927  ndim, dim, lb,
2928  lowerIndx, upperIndx,
2929  elmlen, elmbyval, elmalign);
2930  lenbefore = lenafter = 0; /* keep compiler quiet */
2931  itemsbefore = itemsafter = nolditems = 0;
2932  }
2933  else
2934  {
2935  /*
2936  * here we must allow for possibility of slice larger than orig array
2937  * and/or not adjacent to orig array subscripts
2938  */
2939  int oldlb = ARR_LBOUND(array)[0];
2940  int oldub = oldlb + ARR_DIMS(array)[0] - 1;
2941  int slicelb = Max(oldlb, lowerIndx[0]);
2942  int sliceub = Min(oldub, upperIndx[0]);
2943  char *oldarraydata = ARR_DATA_PTR(array);
2944  bits8 *oldarraybitmap = ARR_NULLBITMAP(array);
2945 
2946  /* count/size of old array entries that will go before the slice */
2947  itemsbefore = Min(slicelb, oldub + 1) - oldlb;
2948  lenbefore = array_nelems_size(oldarraydata, 0, oldarraybitmap,
2949  itemsbefore,
2950  elmlen, elmbyval, elmalign);
2951  /* count/size of old array entries that will be replaced by slice */
2952  if (slicelb > sliceub)
2953  {
2954  nolditems = 0;
2955  olditemsize = 0;
2956  }
2957  else
2958  {
2959  nolditems = sliceub - slicelb + 1;
2960  olditemsize = array_nelems_size(oldarraydata + lenbefore,
2961  itemsbefore, oldarraybitmap,
2962  nolditems,
2963  elmlen, elmbyval, elmalign);
2964  }
2965  /* count/size of old array entries that will go after the slice */
2966  itemsafter = oldub + 1 - Max(sliceub + 1, oldlb);
2967  lenafter = olddatasize - lenbefore - olditemsize;
2968  }
2969 
2970  newsize = overheadlen + olddatasize - olditemsize + newitemsize;
2971 
2972  newarray = (ArrayType *) palloc0(newsize);
2973  SET_VARSIZE(newarray, newsize);
2974  newarray->ndim = ndim;
2975  newarray->dataoffset = newhasnulls ? overheadlen : 0;
2976  newarray->elemtype = ARR_ELEMTYPE(array);
2977  memcpy(ARR_DIMS(newarray), dim, ndim * sizeof(int));
2978  memcpy(ARR_LBOUND(newarray), lb, ndim * sizeof(int));
2979 
2980  if (ndim > 1)
2981  {
2982  /*
2983  * here we do not need to cope with extension of the array; it would
2984  * be a lot more complicated if we had to do so...
2985  */
2986  array_insert_slice(newarray, array, srcArray,
2987  ndim, dim, lb,
2988  lowerIndx, upperIndx,
2989  elmlen, elmbyval, elmalign);
2990  }
2991  else
2992  {
2993  /* fill in data */
2994  memcpy((char *) newarray + overheadlen,
2995  (char *) array + oldoverheadlen,
2996  lenbefore);
2997  memcpy((char *) newarray + overheadlen + lenbefore,
2998  ARR_DATA_PTR(srcArray),
2999  newitemsize);
3000  memcpy((char *) newarray + overheadlen + lenbefore + newitemsize,
3001  (char *) array + oldoverheadlen + lenbefore + olditemsize,
3002  lenafter);
3003  /* fill in nulls bitmap if needed */
3004  if (newhasnulls)
3005  {
3006  bits8 *newnullbitmap = ARR_NULLBITMAP(newarray);
3007  bits8 *oldnullbitmap = ARR_NULLBITMAP(array);
3008 
3009  /* Zero the bitmap to handle marking inserted positions null */
3010  MemSet(newnullbitmap, 0, (nitems + 7) / 8);
3011  array_bitmap_copy(newnullbitmap, addedbefore,
3012  oldnullbitmap, 0,
3013  itemsbefore);
3014  array_bitmap_copy(newnullbitmap, lowerIndx[0] - lb[0],
3015  ARR_NULLBITMAP(srcArray), 0,
3016  nsrcitems);
3017  array_bitmap_copy(newnullbitmap, addedbefore + itemsbefore + nolditems,
3018  oldnullbitmap, itemsbefore + nolditems,
3019  itemsafter);
3020  }
3021  }
3022 
3023  return PointerGetDatum(newarray);
3024 }
3025 
3026 /*
3027  * array_ref : backwards compatibility wrapper for array_get_element
3028  *
3029  * This only works for detoasted/flattened varlena arrays, since the array
3030  * argument is declared as "ArrayType *". However there's enough code like
3031  * that to justify preserving this API.
3032  */
3033 Datum
3034 array_ref(ArrayType *array, int nSubscripts, int *indx,
3035  int arraytyplen, int elmlen, bool elmbyval, char elmalign,
3036  bool *isNull)
3037 {
3038  return array_get_element(PointerGetDatum(array), nSubscripts, indx,
3039  arraytyplen, elmlen, elmbyval, elmalign,
3040  isNull);
3041 }
3042 
3043 /*
3044  * array_set : backwards compatibility wrapper for array_set_element
3045  *
3046  * This only works for detoasted/flattened varlena arrays, since the array
3047  * argument and result are declared as "ArrayType *". However there's enough
3048  * code like that to justify preserving this API.
3049  */
3050 ArrayType *
3051 array_set(ArrayType *array, int nSubscripts, int *indx,
3052  Datum dataValue, bool isNull,
3053  int arraytyplen, int elmlen, bool elmbyval, char elmalign)
3054 {
3055  return DatumGetArrayTypeP(array_set_element(PointerGetDatum(array),
3056  nSubscripts, indx,
3057  dataValue, isNull,
3058  arraytyplen,
3059  elmlen, elmbyval, elmalign));
3060 }
3061 
3062 /*
3063  * array_map()
3064  *
3065  * Map an array through an arbitrary function. Return a new array with
3066  * same dimensions and each source element transformed by fn(). Each
3067  * source element is passed as the first argument to fn(); additional
3068  * arguments to be passed to fn() can be specified by the caller.
3069  * The output array can have a different element type than the input.
3070  *
3071  * Parameters are:
3072  * * fcinfo: a function-call data structure pre-constructed by the caller
3073  * to be ready to call the desired function, with everything except the
3074  * first argument position filled in. In particular, flinfo identifies
3075  * the function fn(), and if nargs > 1 then argument positions after the
3076  * first must be preset to the additional values to be passed. The
3077  * first argument position initially holds the input array value.
3078  * * retType: OID of element type of output array. This must be the same as,
3079  * or binary-compatible with, the result type of fn().
3080  * * amstate: workspace for array_map. Must be zeroed by caller before
3081  * first call, and not touched after that.
3082  *
3083  * It is legitimate to pass a freshly-zeroed ArrayMapState on each call,
3084  * but better performance can be had if the state can be preserved across
3085  * a series of calls.
3086  *
3087  * NB: caller must assure that input array is not NULL. NULL elements in
3088  * the array are OK however.
3089  */
3090 Datum
3091 array_map(FunctionCallInfo fcinfo, Oid retType, ArrayMapState *amstate)
3092 {
3093  AnyArrayType *v;
3094  ArrayType *result;
3095  Datum *values;
3096  bool *nulls;
3097  int *dim;
3098  int ndim;
3099  int nitems;
3100  int i;
3101  int32 nbytes = 0;
3102  int32 dataoffset;
3103  bool hasnulls;
3104  Oid inpType;
3105  int inp_typlen;
3106  bool inp_typbyval;
3107  char inp_typalign;
3108  int typlen;
3109  bool typbyval;
3110  char typalign;
3111  array_iter iter;
3112  ArrayMetaState *inp_extra;
3113  ArrayMetaState *ret_extra;
3114 
3115  /* Get input array */
3116  if (fcinfo->nargs < 1)
3117  elog(ERROR, "invalid nargs: %d", fcinfo->nargs);
3118  if (PG_ARGISNULL(0))
3119  elog(ERROR, "null input array");
3120  v = PG_GETARG_ANY_ARRAY(0);
3121 
3122  inpType = AARR_ELEMTYPE(v);
3123  ndim = AARR_NDIM(v);
3124  dim = AARR_DIMS(v);
3125  nitems = ArrayGetNItems(ndim, dim);
3126 
3127  /* Check for empty array */
3128  if (nitems <= 0)
3129  {
3130  /* Return empty array */
3131  PG_RETURN_ARRAYTYPE_P(construct_empty_array(retType));
3132  }
3133 
3134  /*
3135  * We arrange to look up info about input and return element types only
3136  * once per series of calls, assuming the element type doesn't change
3137  * underneath us.
3138  */
3139  inp_extra = &amstate->inp_extra;
3140  ret_extra = &amstate->ret_extra;
3141 
3142  if (inp_extra->element_type != inpType)
3143  {
3144  get_typlenbyvalalign(inpType,
3145  &inp_extra->typlen,
3146  &inp_extra->typbyval,
3147  &inp_extra->typalign);
3148  inp_extra->element_type = inpType;
3149  }
3150  inp_typlen = inp_extra->typlen;
3151  inp_typbyval = inp_extra->typbyval;
3152  inp_typalign = inp_extra->typalign;
3153 
3154  if (ret_extra->element_type != retType)
3155  {
3156  get_typlenbyvalalign(retType,
3157  &ret_extra->typlen,
3158  &ret_extra->typbyval,
3159  &ret_extra->typalign);
3160  ret_extra->element_type = retType;
3161  }
3162  typlen = ret_extra->typlen;
3163  typbyval = ret_extra->typbyval;
3164  typalign = ret_extra->typalign;
3165 
3166  /* Allocate temporary arrays for new values */
3167  values = (Datum *) palloc(nitems * sizeof(Datum));
3168  nulls = (bool *) palloc(nitems * sizeof(bool));
3169 
3170  /* Loop over source data */
3171  array_iter_setup(&iter, v);
3172  hasnulls = false;
3173 
3174  for (i = 0; i < nitems; i++)
3175  {
3176  bool callit = true;
3177 
3178  /* Get source element, checking for NULL */
3179  fcinfo->arg[0] = array_iter_next(&iter, &fcinfo->argnull[0], i,
3180  inp_typlen, inp_typbyval, inp_typalign);
3181 
3182  /*
3183  * Apply the given function to source elt and extra args.
3184  */
3185  if (fcinfo->flinfo->fn_strict)
3186  {
3187  int j;
3188 
3189  for (j = 0; j < fcinfo->nargs; j++)
3190  {
3191  if (fcinfo->argnull[j])
3192  {
3193  callit = false;
3194  break;
3195  }
3196  }
3197  }
3198 
3199  if (callit)
3200  {
3201  fcinfo->isnull = false;
3202  values[i] = FunctionCallInvoke(fcinfo);
3203  }
3204  else
3205  fcinfo->isnull = true;
3206 
3207  nulls[i] = fcinfo->isnull;
3208  if (fcinfo->isnull)
3209  hasnulls = true;
3210  else
3211  {
3212  /* Ensure data is not toasted */
3213  if (typlen == -1)
3214  values[i] = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
3215  /* Update total result size */
3216  nbytes = att_addlength_datum(nbytes, typlen, values[i]);
3217  nbytes = att_align_nominal(nbytes, typalign);
3218  /* check for overflow of total request */
3219  if (!AllocSizeIsValid(nbytes))
3220  ereport(ERROR,
3221  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
3222  errmsg("array size exceeds the maximum allowed (%d)",
3223  (int) MaxAllocSize)));
3224  }
3225  }
3226 
3227  /* Allocate and initialize the result array */
3228  if (hasnulls)
3229  {
3230  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nitems);
3231  nbytes += dataoffset;
3232  }
3233  else
3234  {
3235  dataoffset = 0; /* marker for no null bitmap */
3236  nbytes += ARR_OVERHEAD_NONULLS(ndim);
3237  }
3238  result = (ArrayType *) palloc0(nbytes);
3239  SET_VARSIZE(result, nbytes);
3240  result->ndim = ndim;
3241  result->dataoffset = dataoffset;
3242  result->elemtype = retType;
3243  memcpy(ARR_DIMS(result), AARR_DIMS(v), ndim * sizeof(int));
3244  memcpy(ARR_LBOUND(result), AARR_LBOUND(v), ndim * sizeof(int));
3245 
3246  /*
3247  * Note: do not risk trying to pfree the results of the called function
3248  */
3249  CopyArrayEls(result,
3250  values, nulls, nitems,
3251  typlen, typbyval, typalign,
3252  false);
3253 
3254  pfree(values);
3255  pfree(nulls);
3256 
3257  PG_RETURN_ARRAYTYPE_P(result);
3258 }
3259 
3260 /*
3261  * construct_array --- simple method for constructing an array object
3262  *
3263  * elems: array of Datum items to become the array contents
3264  * (NULL element values are not supported).
3265  * nelems: number of items
3266  * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
3267  *
3268  * A palloc'd 1-D array object is constructed and returned. Note that
3269  * elem values will be copied into the object even if pass-by-ref type.
3270  *
3271  * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
3272  * from the system catalogs, given the elmtype. However, the caller is
3273  * in a better position to cache this info across multiple uses, or even
3274  * to hard-wire values if the element type is hard-wired.
3275  */
3276 ArrayType *
3277 construct_array(Datum *elems, int nelems,
3278  Oid elmtype,
3279  int elmlen, bool elmbyval, char elmalign)
3280 {
3281  int dims[1];
3282  int lbs[1];
3283 
3284  dims[0] = nelems;
3285  lbs[0] = 1;
3286 
3287  return construct_md_array(elems, NULL, 1, dims, lbs,
3288  elmtype, elmlen, elmbyval, elmalign);
3289 }
3290 
3291 /*
3292  * construct_md_array --- simple method for constructing an array object
3293  * with arbitrary dimensions and possible NULLs
3294  *
3295  * elems: array of Datum items to become the array contents
3296  * nulls: array of is-null flags (can be NULL if no nulls)
3297  * ndims: number of dimensions
3298  * dims: integer array with size of each dimension
3299  * lbs: integer array with lower bound of each dimension
3300  * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
3301  *
3302  * A palloc'd ndims-D array object is constructed and returned. Note that
3303  * elem values will be copied into the object even if pass-by-ref type.
3304  *
3305  * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
3306  * from the system catalogs, given the elmtype. However, the caller is
3307  * in a better position to cache this info across multiple uses, or even
3308  * to hard-wire values if the element type is hard-wired.
3309  */
3310 ArrayType *
3311 construct_md_array(Datum *elems,
3312  bool *nulls,
3313  int ndims,
3314  int *dims,
3315  int *lbs,
3316  Oid elmtype, int elmlen, bool elmbyval, char elmalign)
3317 {
3318  ArrayType *result;
3319  bool hasnulls;
3320  int32 nbytes;
3321  int32 dataoffset;
3322  int i;
3323  int nelems;
3324 
3325  if (ndims < 0) /* we do allow zero-dimension arrays */
3326  ereport(ERROR,
3327  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3328  errmsg("invalid number of dimensions: %d", ndims)));
3329  if (ndims > MAXDIM)
3330  ereport(ERROR,
3331  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
3332  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
3333  ndims, MAXDIM)));
3334 
3335  /* fast track for empty array */
3336  if (ndims == 0)
3337  return construct_empty_array(elmtype);
3338 
3339  nelems = ArrayGetNItems(ndims, dims);
3340 
3341  /* compute required space */
3342  nbytes = 0;
3343  hasnulls = false;
3344  for (i = 0; i < nelems; i++)
3345  {
3346  if (nulls && nulls[i])
3347  {
3348  hasnulls = true;
3349  continue;
3350  }
3351  /* make sure data is not toasted */
3352  if (elmlen == -1)
3353  elems[i] = PointerGetDatum(PG_DETOAST_DATUM(elems[i]));
3354  nbytes = att_addlength_datum(nbytes, elmlen, elems[i]);
3355  nbytes = att_align_nominal(nbytes, elmalign);
3356  /* check for overflow of total request */
3357  if (!AllocSizeIsValid(nbytes))
3358  ereport(ERROR,
3359  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
3360  errmsg("array size exceeds the maximum allowed (%d)",
3361  (int) MaxAllocSize)));
3362  }
3363 
3364  /* Allocate and initialize result array */
3365  if (hasnulls)
3366  {
3367  dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nelems);
3368  nbytes += dataoffset;
3369  }
3370  else
3371  {
3372  dataoffset = 0; /* marker for no null bitmap */
3373  nbytes += ARR_OVERHEAD_NONULLS(ndims);
3374  }
3375  result = (ArrayType *) palloc0(nbytes);
3376  SET_VARSIZE(result, nbytes);
3377  result->ndim = ndims;
3378  result->dataoffset = dataoffset;
3379  result->elemtype = elmtype;
3380  memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
3381  memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));
3382 
3383  CopyArrayEls(result,
3384  elems, nulls, nelems,
3385  elmlen, elmbyval, elmalign,
3386  false);
3387 
3388  return result;
3389 }
3390 
3391 /*
3392  * construct_empty_array --- make a zero-dimensional array of given type
3393  */
3394 ArrayType *
3395 construct_empty_array(Oid elmtype)
3396 {
3397  ArrayType *result;
3398 
3399  result = (ArrayType *) palloc0(sizeof(ArrayType));
3400  SET_VARSIZE(result, sizeof(ArrayType));
3401  result->ndim = 0;
3402  result->dataoffset = 0;
3403  result->elemtype = elmtype;
3404  return result;
3405 }
3406 
3407 /*
3408  * construct_empty_expanded_array: make an empty expanded array
3409  * given only type information. (metacache can be NULL if not needed.)
3410  */
3411 ExpandedArrayHeader *
3412 construct_empty_expanded_array(Oid element_type,
3413  MemoryContext parentcontext,
3414  ArrayMetaState *metacache)
3415 {
3416  ArrayType *array = construct_empty_array(element_type);
3417  Datum d;
3418 
3419  d = expand_array(PointerGetDatum(array), parentcontext, metacache);
3420  pfree(array);
3421  return (ExpandedArrayHeader *) DatumGetEOHP(d);
3422 }
3423 
3424 /*
3425  * deconstruct_array --- simple method for extracting data from an array
3426  *
3427  * array: array object to examine (must not be NULL)
3428  * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
3429  * elemsp: return value, set to point to palloc'd array of Datum values
3430  * nullsp: return value, set to point to palloc'd array of isnull markers
3431  * nelemsp: return value, set to number of extracted values
3432  *
3433  * The caller may pass nullsp == NULL if it does not support NULLs in the
3434  * array. Note that this produces a very uninformative error message,
3435  * so do it only in cases where a NULL is really not expected.
3436  *
3437  * If array elements are pass-by-ref data type, the returned Datums will
3438  * be pointers into the array object.
3439  *
3440  * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
3441  * from the system catalogs, given the elmtype. However, in most current
3442  * uses the type is hard-wired into the caller and so we can save a lookup
3443  * cycle by hard-wiring the type info as well.
3444  */
3445 void
3446 deconstruct_array(ArrayType *array,
3447  Oid elmtype,
3448  int elmlen, bool elmbyval, char elmalign,
3449  Datum **elemsp, bool **nullsp, int *nelemsp)
3450 {
3451  Datum *elems;
3452  bool *nulls;
3453  int nelems;
3454  char *p;
3455  bits8 *bitmap;
3456  int bitmask;
3457  int i;
3458 
3459  Assert(ARR_ELEMTYPE(array) == elmtype);
3460 
3461  nelems = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
3462  *elemsp = elems = (Datum *) palloc(nelems * sizeof(Datum));
3463  if (nullsp)
3464  *nullsp = nulls = (bool *) palloc0(nelems * sizeof(bool));
3465  else
3466  nulls = NULL;
3467  *nelemsp = nelems;
3468 
3469  p = ARR_DATA_PTR(array);
3470  bitmap = ARR_NULLBITMAP(array);
3471  bitmask = 1;
3472 
3473  for (i = 0; i < nelems; i++)
3474  {
3475  /* Get source element, checking for NULL */
3476  if (bitmap && (*bitmap & bitmask) == 0)
3477  {
3478  elems[i] = (Datum) 0;
3479  if (nulls)
3480  nulls[i] = true;
3481  else
3482  ereport(ERROR,
3483  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
3484  errmsg("null array element not allowed in this context")));
3485  }
3486  else
3487  {
3488  elems[i] = fetch_att(p, elmbyval, elmlen);
3489  p = att_addlength_pointer(p, elmlen, p);
3490  p = (char *) att_align_nominal(p, elmalign);
3491  }
3492 
3493  /* advance bitmap pointer if any */
3494  if (bitmap)
3495  {
3496  bitmask <<= 1;
3497  if (bitmask == 0x100)
3498  {
3499  bitmap++;
3500  bitmask = 1;
3501  }
3502  }
3503  }
3504 }
3505 
3506 /*
3507  * array_contains_nulls --- detect whether an array has any null elements
3508  *
3509  * This gives an accurate answer, whereas testing ARR_HASNULL only tells
3510  * if the array *might* contain a null.
3511  */
3512 bool
3513 array_contains_nulls(ArrayType *array)
3514 {
3515  int nelems;
3516  bits8 *bitmap;
3517  int bitmask;
3518 
3519  /* Easy answer if there's no null bitmap */
3520  if (!ARR_HASNULL(array))
3521  return false;
3522 
3523  nelems = ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array));
3524 
3525  bitmap = ARR_NULLBITMAP(array);
3526 
3527  /* check whole bytes of the bitmap byte-at-a-time */
3528  while (nelems >= 8)
3529  {
3530  if (*bitmap != 0xFF)
3531  return true;
3532  bitmap++;
3533  nelems -= 8;
3534  }
3535 
3536  /* check last partial byte */
3537  bitmask = 1;
3538  while (nelems > 0)
3539  {
3540  if ((*bitmap & bitmask) == 0)
3541  return true;
3542  bitmask <<= 1;
3543  nelems--;
3544  }
3545 
3546  return false;
3547 }
3548 
3549 
3550 /*
3551  * array_eq :
3552  * compares two arrays for equality
3553  * result :
3554  * returns true if the arrays are equal, false otherwise.
3555  *
3556  * Note: we do not use array_cmp here, since equality may be meaningful in
3557  * datatypes that don't have a total ordering (and hence no btree support).
3558  */
3559 Datum
3560 array_eq(PG_FUNCTION_ARGS)
3561 {
3562  AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
3563  AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
3564  Oid collation = PG_GET_COLLATION();
3565  int ndims1 = AARR_NDIM(array1);
3566  int ndims2 = AARR_NDIM(array2);
3567  int *dims1 = AARR_DIMS(array1);
3568  int *dims2 = AARR_DIMS(array2);
3569  int *lbs1 = AARR_LBOUND(array1);
3570  int *lbs2 = AARR_LBOUND(array2);
3571  Oid element_type = AARR_ELEMTYPE(array1);
3572  bool result = true;
3573  int nitems;
3574  TypeCacheEntry *typentry;
3575  int typlen;
3576  bool typbyval;
3577  char typalign;
3578  array_iter it1;
3579  array_iter it2;
3580  int i;
3581  FunctionCallInfoData locfcinfo;
3582 
3583  if (element_type != AARR_ELEMTYPE(array2))
3584  ereport(ERROR,
3585  (errcode(ERRCODE_DATATYPE_MISMATCH),
3586  errmsg("cannot compare arrays of different element types")));
3587 
3588  /* fast path if the arrays do not have the same dimensionality */
3589  if (ndims1 != ndims2 ||
3590  memcmp(dims1, dims2, ndims1 * sizeof(int)) != 0 ||
3591  memcmp(lbs1, lbs2, ndims1 * sizeof(int)) != 0)
3592  result = false;
3593  else
3594  {
3595  /*
3596  * We arrange to look up the equality function only once per series of
3597  * calls, assuming the element type doesn't change underneath us. The
3598  * typcache is used so that we have no memory leakage when being used
3599  * as an index support function.
3600  */
3601  typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
3602  if (typentry == NULL ||
3603  typentry->type_id != element_type)
3604  {
3605  typentry = lookup_type_cache(element_type,
3606  TYPECACHE_EQ_OPR_FINFO);
3607  if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
3608  ereport(ERROR,
3609  (errcode(ERRCODE_UNDEFINED_FUNCTION),
3610  errmsg("could not identify an equality operator for type %s",
3611  format_type_be(element_type))));
3612  fcinfo->flinfo->fn_extra = (void *) typentry;
3613  }
3614  typlen = typentry->typlen;
3615  typbyval = typentry->typbyval;
3616  typalign = typentry->typalign;
3617 
3618  /*
3619  * apply the operator to each pair of array elements.
3620  */
3621  InitFunctionCallInfoData(locfcinfo, &typentry->eq_opr_finfo, 2,
3622  collation, NULL, NULL);
3623 
3624  /* Loop over source data */
3625  nitems = ArrayGetNItems(ndims1, dims1);
3626  array_iter_setup(&it1, array1);
3627  array_iter_setup(&it2, array2);
3628 
3629  for (i = 0; i < nitems; i++)
3630  {
3631  Datum elt1;
3632  Datum elt2;
3633  bool isnull1;
3634  bool isnull2;
3635  bool oprresult;
3636 
3637  /* Get elements, checking for NULL */
3638  elt1 = array_iter_next(&it1, &isnull1, i,
3639  typlen, typbyval, typalign);
3640  elt2 = array_iter_next(&it2, &isnull2, i,
3641  typlen, typbyval, typalign);
3642 
3643  /*
3644  * We consider two NULLs equal; NULL and not-NULL are unequal.
3645  */
3646  if (isnull1 && isnull2)
3647  continue;
3648  if (isnull1 || isnull2)
3649  {
3650  result = false;
3651  break;
3652  }
3653 
3654  /*
3655  * Apply the operator to the element pair
3656  */
3657  locfcinfo.arg[0] = elt1;
3658  locfcinfo.arg[1] = elt2;
3659  locfcinfo.argnull[0] = false;
3660  locfcinfo.argnull[1] = false;
3661  locfcinfo.isnull = false;
3662  oprresult = DatumGetBool(FunctionCallInvoke(&locfcinfo));
3663  if (!oprresult)
3664  {
3665  result = false;
3666  break;
3667  }
3668  }
3669  }
3670 
3671  /* Avoid leaking memory when handed toasted input. */
3672  AARR_FREE_IF_COPY(array1, 0);
3673  AARR_FREE_IF_COPY(array2, 1);
3674 
3675  PG_RETURN_BOOL(result);
3676 }
3677 
3678 
3679 /*-----------------------------------------------------------------------------
3680  * array-array bool operators:
3681  * Given two arrays, iterate comparison operators
3682  * over the array. Uses logic similar to text comparison
3683  * functions, except element-by-element instead of
3684  * character-by-character.
3685  *----------------------------------------------------------------------------
3686  */
3687 
3688 Datum
3689 array_ne(PG_FUNCTION_ARGS)
3690 {
3691  PG_RETURN_BOOL(!DatumGetBool(array_eq(fcinfo)));
3692 }
3693 
3694 Datum
3695 array_lt(PG_FUNCTION_ARGS)
3696 {
3697  PG_RETURN_BOOL(array_cmp(fcinfo) < 0);
3698 }
3699 
3700 Datum
3701 array_gt(PG_FUNCTION_ARGS)
3702 {
3703  PG_RETURN_BOOL(array_cmp(fcinfo) > 0);
3704 }
3705 
3706 Datum
3707 array_le(PG_FUNCTION_ARGS)
3708 {
3709  PG_RETURN_BOOL(array_cmp(fcinfo) <= 0);
3710 }
3711 
3712 Datum
3713 array_ge(PG_FUNCTION_ARGS)
3714 {
3715  PG_RETURN_BOOL(array_cmp(fcinfo) >= 0);
3716 }
3717 
3718 Datum
3719 btarraycmp(PG_FUNCTION_ARGS)
3720 {
3721  PG_RETURN_INT32(array_cmp(fcinfo));
3722 }
3723 
3724 /*
3725  * array_cmp()
3726  * Internal comparison function for arrays.
3727  *
3728  * Returns -1, 0 or 1
3729  */
3730 static int
3731 array_cmp(FunctionCallInfo fcinfo)
3732 {
3733  AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
3734  AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
3735  Oid collation = PG_GET_COLLATION();
3736  int ndims1 = AARR_NDIM(array1);
3737  int ndims2 = AARR_NDIM(array2);
3738  int *dims1 = AARR_DIMS(array1);
3739  int *dims2 = AARR_DIMS(array2);
3740  int nitems1 = ArrayGetNItems(ndims1, dims1);
3741  int nitems2 = ArrayGetNItems(ndims2, dims2);
3742  Oid element_type = AARR_ELEMTYPE(array1);
3743  int result = 0;
3744  TypeCacheEntry *typentry;
3745  int typlen;
3746  bool typbyval;
3747  char typalign;
3748  int min_nitems;
3749  array_iter it1;
3750  array_iter it2;
3751  int i;
3752  FunctionCallInfoData locfcinfo;
3753 
3754  if (element_type != AARR_ELEMTYPE(array2))
3755  ereport(ERROR,
3756  (errcode(ERRCODE_DATATYPE_MISMATCH),
3757  errmsg("cannot compare arrays of different element types")));
3758 
3759  /*
3760  * We arrange to look up the comparison function only once per series of
3761  * calls, assuming the element type doesn't change underneath us. The
3762  * typcache is used so that we have no memory leakage when being used as
3763  * an index support function.
3764  */
3765  typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
3766  if (typentry == NULL ||
3767  typentry->type_id != element_type)
3768  {
3769  typentry = lookup_type_cache(element_type,
3770  TYPECACHE_CMP_PROC_FINFO);
3771  if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
3772  ereport(ERROR,
3773  (errcode(ERRCODE_UNDEFINED_FUNCTION),
3774  errmsg("could not identify a comparison function for type %s",
3775  format_type_be(element_type))));
3776  fcinfo->flinfo->fn_extra = (void *) typentry;
3777  }
3778  typlen = typentry->typlen;
3779  typbyval = typentry->typbyval;
3780  typalign = typentry->typalign;
3781 
3782  /*
3783  * apply the operator to each pair of array elements.
3784  */
3785  InitFunctionCallInfoData(locfcinfo, &typentry->cmp_proc_finfo, 2,
3786  collation, NULL, NULL);
3787 
3788  /* Loop over source data */
3789  min_nitems = Min(nitems1, nitems2);
3790  array_iter_setup(&it1, array1);
3791  array_iter_setup(&it2, array2);
3792 
3793  for (i = 0; i < min_nitems; i++)
3794  {
3795  Datum elt1;
3796  Datum elt2;
3797  bool isnull1;
3798  bool isnull2;
3799  int32 cmpresult;
3800 
3801  /* Get elements, checking for NULL */
3802  elt1 = array_iter_next(&it1, &isnull1, i, typlen, typbyval, typalign);
3803  elt2 = array_iter_next(&it2, &isnull2, i, typlen, typbyval, typalign);
3804 
3805  /*
3806  * We consider two NULLs equal; NULL > not-NULL.
3807  */
3808  if (isnull1 && isnull2)
3809  continue;
3810  if (isnull1)
3811  {
3812  /* arg1 is greater than arg2 */
3813  result = 1;
3814  break;
3815  }
3816  if (isnull2)
3817  {
3818  /* arg1 is less than arg2 */
3819  result = -1;
3820  break;
3821  }
3822 
3823  /* Compare the pair of elements */
3824  locfcinfo.arg[0] = elt1;
3825  locfcinfo.arg[1] = elt2;
3826  locfcinfo.argnull[0] = false;
3827  locfcinfo.argnull[1] = false;
3828  locfcinfo.isnull = false;
3829  cmpresult = DatumGetInt32(FunctionCallInvoke(&locfcinfo));
3830 
3831  if (cmpresult == 0)
3832  continue; /* equal */
3833 
3834  if (cmpresult < 0)
3835  {
3836  /* arg1 is less than arg2 */
3837  result = -1;
3838  break;
3839  }
3840  else
3841  {
3842  /* arg1 is greater than arg2 */
3843  result = 1;
3844  break;
3845  }
3846  }
3847 
3848  /*
3849  * If arrays contain same data (up to end of shorter one), apply
3850  * additional rules to sort by dimensionality. The relative significance
3851  * of the different bits of information is historical; mainly we just care
3852  * that we don't say "equal" for arrays of different dimensionality.
3853  */
3854  if (result == 0)
3855  {
3856  if (nitems1 != nitems2)
3857  result = (nitems1 < nitems2) ? -1 : 1;
3858  else if (ndims1 != ndims2)
3859  result = (ndims1 < ndims2) ? -1 : 1;
3860  else
3861  {
3862  for (i = 0; i < ndims1; i++)
3863  {
3864  if (dims1[i] != dims2[i])
3865  {
3866  result = (dims1[i] < dims2[i]) ? -1 : 1;
3867  break;
3868  }
3869  }
3870  if (result == 0)
3871  {
3872  int *lbound1 = AARR_LBOUND(array1);
3873  int *lbound2 = AARR_LBOUND(array2);
3874 
3875  for (i = 0; i < ndims1; i++)
3876  {
3877  if (lbound1[i] != lbound2[i])
3878  {
3879  result = (lbound1[i] < lbound2[i]) ? -1 : 1;
3880  break;
3881  }
3882  }
3883  }
3884  }
3885  }
3886 
3887  /* Avoid leaking memory when handed toasted input. */
3888  AARR_FREE_IF_COPY(array1, 0);
3889  AARR_FREE_IF_COPY(array2, 1);
3890 
3891  return result;
3892 }
3893 
3894 
3895 /*-----------------------------------------------------------------------------
3896  * array hashing
3897  * Hash the elements and combine the results.
3898  *----------------------------------------------------------------------------
3899  */
3900 
3901 Datum
3902 hash_array(PG_FUNCTION_ARGS)
3903 {
3904  AnyArrayType *array = PG_GETARG_ANY_ARRAY(0);
3905  int ndims = AARR_NDIM(array);
3906  int *dims = AARR_DIMS(array);
3907  Oid element_type = AARR_ELEMTYPE(array);
3908  uint32 result = 1;
3909  int nitems;
3910  TypeCacheEntry *typentry;
3911  int typlen;
3912  bool typbyval;
3913  char typalign;
3914  int i;
3915  array_iter iter;
3916  FunctionCallInfoData locfcinfo;
3917 
3918  /*
3919  * We arrange to look up the hash function only once per series of calls,
3920  * assuming the element type doesn't change underneath us. The typcache
3921  * is used so that we have no memory leakage when being used as an index
3922  * support function.
3923  */
3924  typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
3925  if (typentry == NULL ||
3926  typentry->type_id != element_type)
3927  {
3928  typentry = lookup_type_cache(element_type,
3929  TYPECACHE_HASH_PROC_FINFO);
3930  if (!OidIsValid(typentry->hash_proc_finfo.fn_oid))
3931  ereport(ERROR,
3932  (errcode(ERRCODE_UNDEFINED_FUNCTION),
3933  errmsg("could not identify a hash function for type %s",
3934  format_type_be(element_type))));
3935  fcinfo->flinfo->fn_extra = (void *) typentry;
3936  }
3937  typlen = typentry->typlen;
3938  typbyval = typentry->typbyval;
3939  typalign = typentry->typalign;
3940 
3941  /*
3942  * apply the hash function to each array element.
3943  */
3944  InitFunctionCallInfoData(locfcinfo, &typentry->hash_proc_finfo, 1,
3945  InvalidOid, NULL, NULL);
3946 
3947  /* Loop over source data */
3948  nitems = ArrayGetNItems(ndims, dims);
3949  array_iter_setup(&iter, array);
3950 
3951  for (i = 0; i < nitems; i++)
3952  {
3953  Datum elt;
3954  bool isnull;
3955  uint32 elthash;
3956 
3957  /* Get element, checking for NULL */
3958  elt = array_iter_next(&iter, &isnull, i, typlen, typbyval, typalign);
3959 
3960  if (isnull)
3961  {
3962  /* Treat nulls as having hashvalue 0 */
3963  elthash = 0;
3964  }
3965  else
3966  {
3967  /* Apply the hash function */
3968  locfcinfo.arg[0] = elt;
3969  locfcinfo.argnull[0] = false;
3970  locfcinfo.isnull = false;
3971  elthash = DatumGetUInt32(FunctionCallInvoke(&locfcinfo));
3972  }
3973 
3974  /*
3975  * Combine hash values of successive elements by multiplying the
3976  * current value by 31 and adding on the new element's hash value.
3977  *
3978  * The result is a sum in which each element's hash value is
3979  * multiplied by a different power of 31. This is modulo 2^32
3980  * arithmetic, and the powers of 31 modulo 2^32 form a cyclic group of
3981  * order 2^27. So for arrays of up to 2^27 elements, each element's
3982  * hash value is multiplied by a different (odd) number, resulting in
3983  * a good mixing of all the elements' hash values.
3984  */
3985  result = (result << 5) - result + elthash;
3986  }
3987 
3988  /* Avoid leaking memory when handed toasted input. */
3989  AARR_FREE_IF_COPY(array, 0);
3990 
3991  PG_RETURN_UINT32(result);
3992 }
3993 
3994 
3995 /*-----------------------------------------------------------------------------
3996  * array overlap/containment comparisons
3997  * These use the same methods of comparing array elements as array_eq.
3998  * We consider only the elements of the arrays, ignoring dimensionality.
3999  *----------------------------------------------------------------------------
4000  */
4001 
4002 /*
4003  * array_contain_compare :
4004  * compares two arrays for overlap/containment
4005  *
4006  * When matchall is true, return true if all members of array1 are in array2.
4007  * When matchall is false, return true if any members of array1 are in array2.
4008  */
4009 static bool
4010 array_contain_compare(AnyArrayType *array1, AnyArrayType *array2, Oid collation,
4011  bool matchall, void **fn_extra)
4012 {
4013  bool result = matchall;
4014  Oid element_type = AARR_ELEMTYPE(array1);
4015  TypeCacheEntry *typentry;
4016  int nelems1;
4017  Datum *values2;
4018  bool *nulls2;
4019  int nelems2;
4020  int typlen;
4021  bool typbyval;
4022  char typalign;
4023  int i;
4024  int j;
4025  array_iter it1;
4026  FunctionCallInfoData locfcinfo;
4027 
4028  if (element_type != AARR_ELEMTYPE(array2))
4029  ereport(ERROR,
4030  (errcode(ERRCODE_DATATYPE_MISMATCH),
4031  errmsg("cannot compare arrays of different element types")));
4032 
4033  /*
4034  * We arrange to look up the equality function only once per series of
4035  * calls, assuming the element type doesn't change underneath us. The
4036  * typcache is used so that we have no memory leakage when being used as
4037  * an index support function.
4038  */
4039  typentry = (TypeCacheEntry *) *fn_extra;
4040  if (typentry == NULL ||
4041  typentry->type_id != element_type)
4042  {
4043  typentry = lookup_type_cache(element_type,
4044  TYPECACHE_EQ_OPR_FINFO);
4045  if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
4046  ereport(ERROR,
4047  (errcode(ERRCODE_UNDEFINED_FUNCTION),
4048  errmsg("could not identify an equality operator for type %s",
4049  format_type_be(element_type))));
4050  *fn_extra = (void *) typentry;
4051  }
4052  typlen = typentry->typlen;
4053  typbyval = typentry->typbyval;
4054  typalign = typentry->typalign;
4055 
4056  /*
4057  * Since we probably will need to scan array2 multiple times, it's
4058  * worthwhile to use deconstruct_array on it. We scan array1 the hard way
4059  * however, since we very likely won't need to look at all of it.
4060  */
4061  if (VARATT_IS_EXPANDED_HEADER(array2))
4062  {
4063  /* This should be safe even if input is read-only */
4064  deconstruct_expanded_array(&(array2->xpn));
4065  values2 = array2->xpn.dvalues;
4066  nulls2 = array2->xpn.dnulls;
4067  nelems2 = array2->xpn.nelems;
4068  }
4069  else
4070  deconstruct_array(&(array2->flt),
4071  element_type, typlen, typbyval, typalign,
4072  &values2, &nulls2, &nelems2);
4073 
4074  /*
4075  * Apply the comparison operator to each pair of array elements.
4076  */
4077  InitFunctionCallInfoData(locfcinfo, &typentry->eq_opr_finfo, 2,
4078  collation, NULL, NULL);
4079 
4080  /* Loop over source data */
4081  nelems1 = ArrayGetNItems(AARR_NDIM(array1), AARR_DIMS(array1));
4082  array_iter_setup(&it1, array1);
4083 
4084  for (i = 0; i < nelems1; i++)
4085  {
4086  Datum elt1;
4087  bool isnull1;
4088 
4089  /* Get element, checking for NULL */
4090  elt1 = array_iter_next(&it1, &isnull1, i, typlen, typbyval, typalign);
4091 
4092  /*
4093  * We assume that the comparison operator is strict, so a NULL can't
4094  * match anything. XXX this diverges from the "NULL=NULL" behavior of
4095  * array_eq, should we act like that?
4096  */
4097  if (isnull1)
4098  {
4099  if (matchall)
4100  {
4101  result = false;
4102  break;
4103  }
4104  continue;
4105  }
4106 
4107  for (j = 0; j < nelems2; j++)
4108  {
4109  Datum elt2 = values2[j];
4110  bool isnull2 = nulls2 ? nulls2[j] : false;
4111  bool oprresult;
4112 
4113  if (isnull2)
4114  continue; /* can't match */
4115 
4116  /*
4117  * Apply the operator to the element pair
4118  */
4119  locfcinfo.arg[0] = elt1;
4120  locfcinfo.arg[1] = elt2;
4121  locfcinfo.argnull[0] = false;
4122  locfcinfo.argnull[1] = false;
4123  locfcinfo.isnull = false;
4124  oprresult = DatumGetBool(FunctionCallInvoke(&locfcinfo));
4125  if (oprresult)
4126  break;
4127  }
4128 
4129  if (j < nelems2)
4130  {
4131  /* found a match for elt1 */
4132  if (!matchall)
4133  {
4134  result = true;
4135  break;
4136  }
4137  }
4138  else
4139  {
4140  /* no match for elt1 */
4141  if (matchall)
4142  {
4143  result = false;
4144  break;
4145  }
4146  }
4147  }
4148 
4149  return result;
4150 }
4151 
4152 Datum
4153 arrayoverlap(PG_FUNCTION_ARGS)
4154 {
4155  AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
4156  AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
4157  Oid collation = PG_GET_COLLATION();
4158  bool result;
4159 
4160  result = array_contain_compare(array1, array2, collation, false,
4161  &fcinfo->flinfo->fn_extra);
4162 
4163  /* Avoid leaking memory when handed toasted input. */
4164  AARR_FREE_IF_COPY(array1, 0);
4165  AARR_FREE_IF_COPY(array2, 1);
4166 
4167  PG_RETURN_BOOL(result);
4168 }
4169 
4170 Datum
4171 arraycontains(PG_FUNCTION_ARGS)
4172 {
4173  AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
4174  AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
4175  Oid collation = PG_GET_COLLATION();
4176  bool result;
4177 
4178  result = array_contain_compare(array2, array1, collation, true,
4179  &fcinfo->flinfo->fn_extra);
4180 
4181  /* Avoid leaking memory when handed toasted input. */
4182  AARR_FREE_IF_COPY(array1, 0);
4183  AARR_FREE_IF_COPY(array2, 1);
4184 
4185  PG_RETURN_BOOL(result);
4186 }
4187 
4188 Datum
4189 arraycontained(PG_FUNCTION_ARGS)
4190 {
4191  AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
4192  AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
4193  Oid collation = PG_GET_COLLATION();
4194  bool result;
4195 
4196  result = array_contain_compare(array1, array2, collation, true,
4197  &fcinfo->flinfo->fn_extra);
4198 
4199  /* Avoid leaking memory when handed toasted input. */
4200  AARR_FREE_IF_COPY(array1, 0);
4201  AARR_FREE_IF_COPY(array2, 1);
4202 
4203  PG_RETURN_BOOL(result);
4204 }
4205 
4206 
4207 /*-----------------------------------------------------------------------------
4208  * Array iteration functions
4209  * These functions are used to iterate efficiently through arrays
4210  *-----------------------------------------------------------------------------
4211  */
4212 
4213 /*
4214  * array_create_iterator --- set up to iterate through an array
4215  *
4216  * If slice_ndim is zero, we will iterate element-by-element; the returned
4217  * datums are of the array's element type.
4218  *
4219  * If slice_ndim is 1..ARR_NDIM(arr), we will iterate by slices: the
4220  * returned datums are of the same array type as 'arr', but of size
4221  * equal to the rightmost N dimensions of 'arr'.
4222  *
4223  * The passed-in array must remain valid for the lifetime of the iterator.
4224  */
4225 ArrayIterator
4226 array_create_iterator(ArrayType *arr, int slice_ndim, ArrayMetaState *mstate)
4227 {
4228  ArrayIterator iterator = palloc0(sizeof(ArrayIteratorData));
4229 
4230  /*
4231  * Sanity-check inputs --- caller should have got this right already
4232  */
4233  Assert(PointerIsValid(arr));
4234  if (slice_ndim < 0 || slice_ndim > ARR_NDIM(arr))
4235  elog(ERROR, "invalid arguments to array_create_iterator");
4236 
4237  /*
4238  * Remember basic info about the array and its element type
4239  */
4240  iterator->arr = arr;
4241  iterator->nullbitmap = ARR_NULLBITMAP(arr);
4242  iterator->nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr));
4243 
4244  if (mstate != NULL)
4245  {
4246  Assert(mstate->element_type == ARR_ELEMTYPE(arr));
4247 
4248  iterator->typlen = mstate->typlen;
4249  iterator->typbyval = mstate->typbyval;
4250  iterator->typalign = mstate->typalign;
4251  }
4252  else
4253  get_typlenbyvalalign(ARR_ELEMTYPE(arr),
4254  &iterator->typlen,
4255  &iterator->typbyval,
4256  &iterator->typalign);
4257 
4258  /*
4259  * Remember the slicing parameters.
4260  */
4261  iterator->slice_ndim = slice_ndim;
4262 
4263  if (slice_ndim > 0)
4264  {
4265  /*
4266  * Get pointers into the array's dims and lbound arrays to represent
4267  * the dims/lbound arrays of a slice. These are the same as the
4268  * rightmost N dimensions of the array.
4269  */
4270  iterator->slice_dims = ARR_DIMS(arr) + ARR_NDIM(arr) - slice_ndim;
4271  iterator->slice_lbound = ARR_LBOUND(arr) + ARR_NDIM(arr) - slice_ndim;
4272 
4273  /*
4274  * Compute number of elements in a slice.
4275  */
4276  iterator->slice_len = ArrayGetNItems(slice_ndim,
4277  iterator->slice_dims);
4278 
4279  /*
4280  * Create workspace for building sub-arrays.
4281  */
4282  iterator->slice_values = (Datum *)
4283  palloc(iterator->slice_len * sizeof(Datum));
4284  iterator->slice_nulls = (bool *)
4285  palloc(iterator->slice_len * sizeof(bool));
4286  }
4287 
4288  /*
4289  * Initialize our data pointer and linear element number. These will
4290  * advance through the array during array_iterate().
4291  */
4292  iterator->data_ptr = ARR_DATA_PTR(arr);
4293  iterator->current_item = 0;
4294 
4295  return iterator;
4296 }
4297 
4298 /*
4299  * Iterate through the array referenced by 'iterator'.
4300  *
4301  * As long as there is another element (or slice), return it into
4302  * *value / *isnull, and return true. Return false when no more data.
4303  */
4304 bool
4305 array_iterate(ArrayIterator iterator, Datum *value, bool *isnull)
4306 {
4307  /* Done if we have reached the end of the array */
4308  if (iterator->current_item >= iterator->nitems)
4309  return false;
4310 
4311  if (iterator->slice_ndim == 0)
4312  {
4313  /*
4314  * Scalar case: return one element.
4315  */
4316  if (array_get_isnull(iterator->nullbitmap, iterator->current_item++))
4317  {
4318  *isnull = true;
4319  *value = (Datum) 0;
4320  }
4321  else
4322  {
4323  /* non-NULL, so fetch the individual Datum to return */
4324  char *p = iterator->data_ptr;
4325 
4326  *isnull = false;
4327  *value = fetch_att(p, iterator->typbyval, iterator->typlen);
4328 
4329  /* Move our data pointer forward to the next element */
4330  p = att_addlength_pointer(p, iterator->typlen, p);
4331  p = (char *) att_align_nominal(p, iterator->typalign);
4332  iterator->data_ptr = p;
4333  }
4334  }
4335  else
4336  {
4337  /*
4338  * Slice case: build and return an array of the requested size.
4339  */
4340  ArrayType *result;
4341  Datum *values = iterator->slice_values;
4342  bool *nulls = iterator->slice_nulls;
4343  char *p = iterator->data_ptr;
4344  int i;
4345 
4346  for (i = 0; i < iterator->slice_len; i++)
4347  {
4348  if (array_get_isnull(iterator->nullbitmap,
4349  iterator->current_item++))
4350  {
4351  nulls[i] = true;
4352  values[i] = (Datum) 0;
4353  }
4354  else
4355  {
4356  nulls[i] = false;
4357  values[i] = fetch_att(p, iterator->typbyval, iterator->typlen);
4358 
4359  /* Move our data pointer forward to the next element */
4360  p = att_addlength_pointer(p, iterator->typlen, p);
4361  p = (char *) att_align_nominal(p, iterator->typalign);
4362  }
4363  }
4364 
4365  iterator->data_ptr = p;
4366 
4367  result = construct_md_array(values,
4368  nulls,
4369  iterator->slice_ndim,
4370  iterator->slice_dims,
4371  iterator->slice_lbound,
4372  ARR_ELEMTYPE(iterator->arr),
4373  iterator->typlen,
4374  iterator->typbyval,
4375  iterator->typalign);
4376 
4377  *isnull = false;
4378  *value = PointerGetDatum(result);
4379  }
4380 
4381  return true;
4382 }
4383 
4384 /*
4385  * Release an ArrayIterator data structure
4386  */
4387 void
4388 array_free_iterator(ArrayIterator iterator)
4389 {
4390  if (iterator->slice_ndim > 0)
4391  {
4392  pfree(iterator->slice_values);
4393  pfree(iterator->slice_nulls);
4394  }
4395  pfree(iterator);
4396 }
4397 
4398 
4399 /***************************************************************************/
4400 /******************| Support Routines |*****************/
4401 /***************************************************************************/
4402 
4403 /*
4404  * Check whether a specific array element is NULL
4405  *
4406  * nullbitmap: pointer to array's null bitmap (NULL if none)
4407  * offset: 0-based linear element number of array element
4408  */
4409 static bool
4410 array_get_isnull(const bits8 *nullbitmap, int offset)
4411 {
4412  if (nullbitmap == NULL)
4413  return false; /* assume not null */
4414  if (nullbitmap[offset / 8] & (1 << (offset % 8)))
4415  return false; /* not null */
4416  return true;
4417 }
4418 
4419 /*
4420  * Set a specific array element's null-bitmap entry
4421  *
4422  * nullbitmap: pointer to array's null bitmap (mustn't be NULL)
4423  * offset: 0-based linear element number of array element
4424  * isNull: null status to set
4425  */
4426 static void
4427 array_set_isnull(bits8 *nullbitmap, int offset, bool isNull)
4428 {
4429  int bitmask;
4430 
4431  nullbitmap += offset / 8;
4432  bitmask = 1 << (offset % 8);
4433  if (isNull)
4434  *nullbitmap &= ~bitmask;
4435  else
4436  *nullbitmap |= bitmask;
4437 }
4438 
4439 /*
4440  * Fetch array element at pointer, converted correctly to a Datum
4441  *
4442  * Caller must have handled case of NULL element
4443  */
4444 static Datum
4445 ArrayCast(char *value, bool byval, int len)
4446 {
4447  return fetch_att(value, byval, len);
4448 }
4449 
4450 /*
4451  * Copy datum to *dest and return total space used (including align padding)
4452  *
4453  * Caller must have handled case of NULL element
4454  */
4455 static int
4456 ArrayCastAndSet(Datum src,
4457  int typlen,
4458  bool typbyval,
4459  char typalign,
4460  char *dest)
4461 {
4462  int inc;
4463 
4464  if (typlen > 0)
4465  {
4466  if (typbyval)
4467  store_att_byval(dest, src, typlen);
4468  else
4469  memmove(dest, DatumGetPointer(src), typlen);
4470  inc = att_align_nominal(typlen, typalign);
4471  }
4472  else
4473  {
4474  Assert(!typbyval);
4475  inc = att_addlength_datum(0, typlen, src);
4476  memmove(dest, DatumGetPointer(src), inc);
4477  inc = att_align_nominal(inc, typalign);
4478  }
4479 
4480  return inc;
4481 }
4482 
4483 /*
4484  * Advance ptr over nitems array elements
4485  *
4486  * ptr: starting location in array
4487  * offset: 0-based linear element number of first element (the one at *ptr)
4488  * nullbitmap: start of array's null bitmap, or NULL if none
4489  * nitems: number of array elements to advance over (>= 0)
4490  * typlen, typbyval, typalign: storage parameters of array element datatype
4491  *
4492  * It is caller's responsibility to ensure that nitems is within range
4493  */
4494 static char *
4495 array_seek(char *ptr, int offset, bits8 *nullbitmap, int nitems,
4496  int typlen, bool typbyval, char typalign)
4497 {
4498  int bitmask;
4499  int i;
4500 
4501  /* easy if fixed-size elements and no NULLs */
4502  if (typlen > 0 && !nullbitmap)
4503  return ptr + nitems * ((Size) att_align_nominal(typlen, typalign));
4504 
4505  /* seems worth having separate loops for NULL and no-NULLs cases */
4506  if (nullbitmap)
4507  {
4508  nullbitmap += offset / 8;
4509  bitmask = 1 << (offset % 8);
4510 
4511  for (i = 0; i < nitems; i++)
4512  {
4513  if (*nullbitmap & bitmask)
4514  {
4515  ptr = att_addlength_pointer(ptr, typlen, ptr);
4516  ptr = (char *) att_align_nominal(ptr, typalign);
4517  }
4518  bitmask <<= 1;
4519  if (bitmask == 0x100)
4520  {
4521  nullbitmap++;
4522  bitmask = 1;
4523  }
4524  }
4525  }
4526  else
4527  {
4528  for (i = 0; i < nitems; i++)
4529  {
4530  ptr = att_addlength_pointer(ptr, typlen, ptr);
4531  ptr = (char *) att_align_nominal(ptr, typalign);
4532  }
4533  }
4534  return ptr;
4535 }
4536 
4537 /*
4538  * Compute total size of the nitems array elements starting at *ptr
4539  *
4540  * Parameters same as for array_seek
4541  */
4542 static int
4543 array_nelems_size(char *ptr, int offset, bits8 *nullbitmap, int nitems,
4544  int typlen, bool typbyval, char typalign)
4545 {
4546  return array_seek(ptr, offset, nullbitmap, nitems,
4547  typlen, typbyval, typalign) - ptr;
4548 }
4549 
4550 /*
4551  * Copy nitems array elements from srcptr to destptr
4552  *
4553  * destptr: starting destination location (must be enough room!)
4554  * nitems: number of array elements to copy (>= 0)
4555  * srcptr: starting location in source array
4556  * offset: 0-based linear element number of first element (the one at *srcptr)
4557  * nullbitmap: start of source array's null bitmap, or NULL if none
4558  * typlen, typbyval, typalign: storage parameters of array element datatype
4559  *
4560  * Returns number of bytes copied
4561  *
4562  * NB: this does not take care of setting up the destination's null bitmap!
4563  */
4564 static int
4565 array_copy(char *destptr, int nitems,
4566  char *srcptr, int offset, bits8 *nullbitmap,
4567  int typlen, bool typbyval, char typalign)
4568 {
4569  int numbytes;
4570 
4571  numbytes = array_nelems_size(srcptr, offset, nullbitmap, nitems,
4572  typlen, typbyval, typalign);
4573  memcpy(destptr, srcptr, numbytes);
4574  return numbytes;
4575 }
4576 
4577 /*
4578  * Copy nitems null-bitmap bits from source to destination
4579  *
4580  * destbitmap: start of destination array's null bitmap (mustn't be NULL)
4581  * destoffset: 0-based linear element number of first dest element
4582  * srcbitmap: start of source array's null bitmap, or NULL if none
4583  * srcoffset: 0-based linear element number of first source element
4584  * nitems: number of bits to copy (>= 0)
4585  *
4586  * If srcbitmap is NULL then we assume the source is all-non-NULL and
4587  * fill 1's into the destination bitmap. Note that only the specified
4588  * bits in the destination map are changed, not any before or after.
4589  *
4590  * Note: this could certainly be optimized using standard bitblt methods.
4591  * However, it's not clear that the typical Postgres array has enough elements
4592  * to make it worth worrying too much. For the moment, KISS.
4593  */
4594 void
4595 array_bitmap_copy(bits8 *destbitmap, int destoffset,
4596  const bits8 *srcbitmap, int srcoffset,
4597  int nitems)
4598 {
4599  int destbitmask,
4600  destbitval,
4601  srcbitmask,
4602  srcbitval;
4603 
4604  Assert(destbitmap);
4605  if (nitems <= 0)
4606  return; /* don't risk fetch off end of memory */
4607  destbitmap += destoffset / 8;
4608  destbitmask = 1 << (destoffset % 8);
4609  destbitval = *destbitmap;
4610  if (srcbitmap)
4611  {
4612  srcbitmap += srcoffset / 8;
4613  srcbitmask = 1 << (srcoffset % 8);
4614  srcbitval = *srcbitmap;
4615  while (nitems-- > 0)
4616  {
4617  if (srcbitval & srcbitmask)
4618  destbitval |= destbitmask;
4619  else
4620  destbitval &= ~destbitmask;
4621  destbitmask <<= 1;
4622  if (destbitmask == 0x100)
4623  {
4624  *destbitmap++ = destbitval;
4625  destbitmask = 1;
4626  if (nitems > 0)
4627  destbitval = *destbitmap;
4628  }
4629  srcbitmask <<= 1;
4630  if (srcbitmask == 0x100)
4631  {
4632  srcbitmap++;
4633  srcbitmask = 1;
4634  if (nitems > 0)
4635  srcbitval = *srcbitmap;
4636  }
4637  }
4638  if (destbitmask != 1)
4639  *destbitmap = destbitval;
4640  }
4641  else
4642  {
4643  while (nitems-- > 0)
4644  {
4645  destbitval |= destbitmask;
4646  destbitmask <<= 1;
4647  if (destbitmask == 0x100)
4648  {
4649  *destbitmap++ = destbitval;
4650  destbitmask = 1;
4651  if (nitems > 0)
4652  destbitval = *destbitmap;
4653  }
4654  }
4655  if (destbitmask != 1)
4656  *destbitmap = destbitval;
4657  }
4658 }
4659 
4660 /*
4661  * Compute space needed for a slice of an array
4662  *
4663  * We assume the caller has verified that the slice coordinates are valid.
4664  */
4665 static int
4666 array_slice_size(char *arraydataptr, bits8 *arraynullsptr,
4667  int ndim, int *dim, int *lb,
4668  int *st, int *endp,
4669  int typlen, bool typbyval, char typalign)
4670 {
4671  int src_offset,
4672  span[MAXDIM],
4673  prod[MAXDIM],
4674  dist[MAXDIM],
4675  indx[MAXDIM];
4676  char *ptr;
4677  int i,
4678  j,
4679  inc;
4680  int count = 0;
4681 
4682  mda_get_range(ndim, span, st, endp);
4683 
4684  /* Pretty easy for fixed element length without nulls ... */
4685  if (typlen > 0 && !arraynullsptr)
4686  return ArrayGetNItems(ndim, span) * att_align_nominal(typlen, typalign);
4687 
4688  /* Else gotta do it the hard way */
4689  src_offset = ArrayGetOffset(ndim, dim, lb, st);
4690  ptr = array_seek(arraydataptr, 0, arraynullsptr, src_offset,
4691  typlen, typbyval, typalign);
4692  mda_get_prod(ndim, dim, prod);
4693  mda_get_offset_values(ndim, dist, prod, span);
4694  for (i = 0; i < ndim; i++)
4695  indx[i] = 0;
4696  j = ndim - 1;
4697  do
4698  {
4699  if (dist[j])
4700  {
4701  ptr = array_seek(ptr, src_offset, arraynullsptr, dist[j],
4702  typlen, typbyval, typalign);
4703  src_offset += dist[j];
4704  }
4705  if (!array_get_isnull(arraynullsptr, src_offset))
4706  {
4707  inc = att_addlength_pointer(0, typlen, ptr);
4708  inc = att_align_nominal(inc, typalign);
4709  ptr += inc;
4710  count += inc;
4711  }
4712  src_offset++;
4713  } while ((j = mda_next_tuple(ndim, indx, span)) != -1);
4714  return count;
4715 }
4716 
4717 /*
4718  * Extract a slice of an array into consecutive elements in the destination
4719  * array.
4720  *
4721  * We assume the caller has verified that the slice coordinates are valid,
4722  * allocated enough storage for the result, and initialized the header
4723  * of the new array.
4724  */
4725 static void
4726 array_extract_slice(ArrayType *newarray,
4727  int ndim,
4728  int *dim,
4729  int *lb,
4730  char *arraydataptr,
4731  bits8 *arraynullsptr,
4732  int *st,
4733  int *endp,
4734  int typlen,
4735  bool typbyval,
4736  char typalign)
4737 {
4738  char *destdataptr = ARR_DATA_PTR(newarray);
4739  bits8 *destnullsptr = ARR_NULLBITMAP(newarray);
4740  char *srcdataptr;
4741  int src_offset,
4742  dest_offset,
4743  prod[MAXDIM],
4744  span[MAXDIM],
4745  dist[MAXDIM],
4746  indx[MAXDIM];
4747  int i,
4748  j,
4749  inc;
4750 
4751  src_offset = ArrayGetOffset(ndim, dim, lb, st);
4752  srcdataptr = array_seek(arraydataptr, 0, arraynullsptr, src_offset,
4753  typlen, typbyval, typalign);
4754  mda_get_prod(ndim, dim, prod);
4755  mda_get_range(ndim, span, st, endp);
4756  mda_get_offset_values(ndim, dist, prod, span);
4757  for (i = 0; i < ndim; i++)
4758  indx[i] = 0;
4759  dest_offset = 0;
4760  j = ndim - 1;
4761  do
4762  {
4763  if (dist[j])
4764  {
4765  /* skip unwanted elements */
4766  srcdataptr = array_seek(srcdataptr, src_offset, arraynullsptr,
4767  dist[j],
4768  typlen, typbyval, typalign);
4769  src_offset += dist[j];
4770  }
4771  inc = array_copy(destdataptr, 1,
4772  srcdataptr, src_offset, arraynullsptr,
4773  typlen, typbyval, typalign);
4774  if (destnullsptr)
4775  array_bitmap_copy(destnullsptr, dest_offset,
4776  arraynullsptr, src_offset,
4777  1);
4778  destdataptr += inc;
4779  srcdataptr += inc;
4780  src_offset++;
4781  dest_offset++;
4782  } while ((j = mda_next_tuple(ndim, indx, span)) != -1);
4783 }
4784 
4785 /*
4786  * Insert a slice into an array.
4787  *
4788  * ndim/dim[]/lb[] are dimensions of the original array. A new array with
4789  * those same dimensions is to be constructed. destArray must already
4790  * have been allocated and its header initialized.
4791  *
4792  * st[]/endp[] identify the slice to be replaced. Elements within the slice
4793  * volume are taken from consecutive elements of the srcArray; elements
4794  * outside it are copied from origArray.
4795  *
4796  * We assume the caller has verified that the slice coordinates are valid.
4797  */
4798 static void
4799 array_insert_slice(ArrayType *destArray,
4800  ArrayType *origArray,
4801  ArrayType *srcArray,
4802  int ndim,
4803  int *dim,
4804  int *lb,
4805  int *st,
4806  int *endp,
4807  int typlen,
4808  bool typbyval,
4809  char typalign)
4810 {
4811  char *destPtr = ARR_DATA_PTR(destArray);
4812  char *origPtr = ARR_DATA_PTR(origArray);
4813  char *srcPtr = ARR_DATA_PTR(srcArray);
4814  bits8 *destBitmap = ARR_NULLBITMAP(destArray);
4815  bits8 *origBitmap = ARR_NULLBITMAP(origArray);
4816  bits8 *srcBitmap = ARR_NULLBITMAP(srcArray);
4817  int orignitems = ArrayGetNItems(ARR_NDIM(origArray),
4818  ARR_DIMS(origArray));
4819  int dest_offset,
4820  orig_offset,
4821  src_offset,
4822  prod[MAXDIM],
4823  span[MAXDIM],
4824  dist[MAXDIM],
4825  indx[MAXDIM];
4826  int i,
4827  j,
4828  inc;
4829 
4830  dest_offset = ArrayGetOffset(ndim, dim, lb, st);
4831  /* copy items before the slice start */
4832  inc = array_copy(destPtr, dest_offset,
4833  origPtr, 0, origBitmap,
4834  typlen, typbyval, typalign);
4835  destPtr += inc;
4836  origPtr += inc;
4837  if (destBitmap)
4838  array_bitmap_copy(destBitmap, 0, origBitmap, 0, dest_offset);
4839  orig_offset = dest_offset;
4840  mda_get_prod(ndim, dim, prod);
4841  mda_get_range(ndim, span, st, endp);
4842  mda_get_offset_values(ndim, dist, prod, span);
4843  for (i = 0; i < ndim; i++)
4844  indx[i] = 0;
4845  src_offset = 0;
4846  j = ndim - 1;
4847  do
4848  {
4849  /* Copy/advance over elements between here and next part of slice */
4850  if (dist[j])
4851  {
4852  inc = array_copy(destPtr, dist[j],
4853  origPtr, orig_offset, origBitmap,
4854  typlen, typbyval, typalign);
4855  destPtr += inc;
4856  origPtr += inc;
4857  if (destBitmap)
4858  array_bitmap_copy(destBitmap, dest_offset,
4859  origBitmap, orig_offset,
4860  dist[j]);
4861  dest_offset += dist[j];
4862  orig_offset += dist[j];
4863  }
4864  /* Copy new element at this slice position */
4865  inc = array_copy(destPtr, 1,
4866  srcPtr, src_offset, srcBitmap,
4867  typlen, typbyval, typalign);
4868  if (destBitmap)
4869  array_bitmap_copy(destBitmap, dest_offset,
4870  srcBitmap, src_offset,
4871  1);
4872  destPtr += inc;
4873  srcPtr += inc;
4874  dest_offset++;
4875  src_offset++;
4876  /* Advance over old element at this slice position */
4877  origPtr = array_seek(origPtr, orig_offset, origBitmap, 1,
4878  typlen, typbyval, typalign);
4879  orig_offset++;
4880  } while ((j = mda_next_tuple(ndim, indx, span)) != -1);
4881 
4882  /* don't miss any data at the end */
4883  array_copy(destPtr, orignitems - orig_offset,
4884  origPtr, orig_offset, origBitmap,
4885  typlen, typbyval, typalign);
4886  if (destBitmap)
4887  array_bitmap_copy(destBitmap, dest_offset,
4888  origBitmap, orig_offset,
4889  orignitems - orig_offset);
4890 }
4891 
4892 /*
4893  * initArrayResult - initialize an empty ArrayBuildState
4894  *
4895  * element_type is the array element type (must be a valid array element type)
4896  * rcontext is where to keep working state
4897  * subcontext is a flag determining whether to use a separate memory context
4898  *
4899  * Note: there are two common schemes for using accumArrayResult().
4900  * In the older scheme, you start with a NULL ArrayBuildState pointer, and
4901  * call accumArrayResult once per element. In this scheme you end up with
4902  * a NULL pointer if there were no elements, which you need to special-case.
4903  * In the newer scheme, call initArrayResult and then call accumArrayResult
4904  * once per element. In this scheme you always end with a non-NULL pointer
4905  * that you can pass to makeArrayResult; you get an empty array if there
4906  * were no elements. This is preferred if an empty array is what you want.
4907  *
4908  * It's possible to choose whether to create a separate memory context for the
4909  * array build state, or whether to allocate it directly within rcontext.
4910  *
4911  * When there are many concurrent small states (e.g. array_agg() using hash
4912  * aggregation of many small groups), using a separate memory context for each
4913  * one may result in severe memory bloat. In such cases, use the same memory
4914  * context to initialize all such array build states, and pass
4915  * subcontext=false.
4916  *
4917  * In cases when the array build states have different lifetimes, using a
4918  * single memory context is impractical. Instead, pass subcontext=true so that
4919  * the array build states can be freed individually.
4920  */
4921 ArrayBuildState *
4922 initArrayResult(Oid element_type, MemoryContext rcontext, bool subcontext)
4923 {
4924  ArrayBuildState *astate;
4925  MemoryContext arr_context = rcontext;
4926 
4927  /* Make a temporary context to hold all the junk */
4928  if (subcontext)
4929  arr_context = AllocSetContextCreate(rcontext,
4930  "accumArrayResult",
4931  ALLOCSET_DEFAULT_MINSIZE,
4932  ALLOCSET_DEFAULT_INITSIZE,
4933  ALLOCSET_DEFAULT_MAXSIZE);
4934 
4935  astate = (ArrayBuildState *)
4936  MemoryContextAlloc(arr_context, sizeof(ArrayBuildState));
4937  astate->mcontext = arr_context;
4938  astate->private_cxt = subcontext;
4939  astate->alen = (subcontext ? 64 : 8); /* arbitrary starting array
4940  * size */
4941  astate->dvalues = (Datum *)
4942  MemoryContextAlloc(arr_context, astate->alen * sizeof(Datum));
4943  astate->dnulls = (bool *)
4944  MemoryContextAlloc(arr_context, astate->alen * sizeof(bool));
4945  astate->nelems = 0;
4946  astate->element_type = element_type;
4947  get_typlenbyvalalign(element_type,
4948  &astate->typlen,
4949  &astate->typbyval,
4950  &astate->typalign);
4951 
4952  return astate;
4953 }
4954 
4955 /*
4956  * accumArrayResult - accumulate one (more) Datum for an array result
4957  *
4958  * astate is working state (can be NULL on first call)
4959  * dvalue/disnull represent the new Datum to append to the array
4960  * element_type is the Datum's type (must be a valid array element type)
4961  * rcontext is where to keep working state
4962  */
4963 ArrayBuildState *
4964 accumArrayResult(ArrayBuildState *astate,
4965  Datum dvalue, bool disnull,
4966  Oid element_type,
4967  MemoryContext rcontext)
4968 {
4969  MemoryContext oldcontext;
4970 
4971  if (astate == NULL)
4972  {
4973  /* First time through --- initialize */
4974  astate = initArrayResult(element_type, rcontext, true);
4975  }
4976  else
4977  {
4978  Assert(astate->element_type == element_type);
4979  }
4980 
4981  oldcontext = MemoryContextSwitchTo(astate->mcontext);
4982 
4983  /* enlarge dvalues[]/dnulls[] if needed */
4984  if (astate->nelems >= astate->alen)
4985  {
4986  astate->alen *= 2;
4987  astate->dvalues = (Datum *)
4988  repalloc(astate->dvalues, astate->alen * sizeof(Datum));
4989  astate->dnulls = (bool *)
4990  repalloc(astate->dnulls, astate->alen * sizeof(bool));
4991  }
4992 
4993  /*
4994  * Ensure pass-by-ref stuff is copied into mcontext; and detoast it too if
4995  * it's varlena. (You might think that detoasting is not needed here
4996  * because construct_md_array can detoast the array elements later.
4997  * However, we must not let construct_md_array modify the ArrayBuildState
4998  * because that would mean array_agg_finalfn damages its input, which is
4999  * verboten. Also, this way frequently saves one copying step.)
5000  */
5001  if (!disnull && !astate->typbyval)
5002  {
5003  if (astate->typlen == -1)
5004  dvalue = PointerGetDatum(PG_DETOAST_DATUM_COPY(dvalue));
5005  else
5006  dvalue = datumCopy(dvalue, astate->typbyval, astate->typlen);
5007  }
5008 
5009  astate->dvalues[astate->nelems] = dvalue;
5010  astate->dnulls[astate->nelems] = disnull;
5011  astate->nelems++;
5012 
5013  MemoryContextSwitchTo(oldcontext);
5014 
5015  return astate;
5016 }
5017 
5018 /*
5019  * makeArrayResult - produce 1-D final result of accumArrayResult
5020  *
5021  * Note: only releases astate if it was initialized within a separate memory
5022  * context (i.e. using subcontext=true when calling initArrayResult).
5023  *
5024  * astate is working state (must not be NULL)
5025  * rcontext is where to construct result
5026  */
5027 Datum
5028 makeArrayResult(ArrayBuildState *astate,
5029  MemoryContext rcontext)
5030 {
5031  int ndims;
5032  int dims[1];
5033  int lbs[1];
5034 
5035  /* If no elements were presented, we want to create an empty array */
5036  ndims = (astate->nelems > 0) ? 1 : 0;
5037  dims[0] = astate->nelems;
5038  lbs[0] = 1;
5039 
5040  return makeMdArrayResult(astate, ndims, dims, lbs, rcontext,
5041  astate->private_cxt);
5042 }
5043 
5044 /*
5045  * makeMdArrayResult - produce multi-D final result of accumArrayResult
5046  *
5047  * beware: no check that specified dimensions match the number of values
5048  * accumulated.
5049  *
5050  * Note: if the astate was not initialized within a separate memory context
5051  * (that is, initArrayResult was called with subcontext=false), then using
5052  * release=true is illegal. Instead, release astate along with the rest of its
5053  * context when appropriate.
5054  *
5055  * astate is working state (must not be NULL)
5056  * rcontext is where to construct result
5057  * release is true if okay to release working state
5058  */
5059 Datum
5060 makeMdArrayResult(ArrayBuildState *astate,
5061  int ndims,
5062  int *dims,
5063  int *lbs,
5064  MemoryContext rcontext,
5065  bool release)
5066 {
5067  ArrayType *result;
5068  MemoryContext oldcontext;
5069 
5070  /* Build the final array result in rcontext */
5071  oldcontext = MemoryContextSwitchTo(rcontext);
5072 
5073  result = construct_md_array(astate->dvalues,
5074  astate->dnulls,
5075  ndims,
5076  dims,
5077  lbs,
5078  astate->element_type,
5079  astate->typlen,
5080  astate->typbyval,
5081  astate->typalign);
5082 
5083  MemoryContextSwitchTo(oldcontext);
5084 
5085  /* Clean up all the junk */
5086  if (release)
5087  {
5088  Assert(astate->private_cxt);
5089  MemoryContextDelete(astate->mcontext);
5090  }
5091 
5092  return PointerGetDatum(result);
5093 }
5094 
5095 /*
5096  * The following three functions provide essentially the same API as
5097  * initArrayResult/accumArrayResult/makeArrayResult, but instead of accepting
5098  * inputs that are array elements, they accept inputs that are arrays and
5099  * produce an output array having N+1 dimensions. The inputs must all have
5100  * identical dimensionality as well as element type.
5101  */
5102 
5103 /*
5104  * initArrayResultArr - initialize an empty ArrayBuildStateArr
5105  *
5106  * array_type is the array type (must be a valid varlena array type)
5107  * element_type is the type of the array's elements (lookup if InvalidOid)
5108  * rcontext is where to keep working state
5109  * subcontext is a flag determining whether to use a separate memory context
5110  */
5111 ArrayBuildStateArr *
5112 initArrayResultArr(Oid array_type, Oid element_type, MemoryContext rcontext,
5113  bool subcontext)
5114 {
5115  ArrayBuildStateArr *astate;
5116  MemoryContext arr_context = rcontext; /* by default use the parent
5117  * ctx */
5118 
5119  /* Lookup element type, unless element_type already provided */
5120  if (!OidIsValid(element_type))
5121  {
5122  element_type = get_element_type(array_type);
5123 
5124  if (!OidIsValid(element_type))
5125  ereport(ERROR,
5126  (errcode(ERRCODE_DATATYPE_MISMATCH),
5127  errmsg("data type %s is not an array type",
5128  format_type_be(array_type))));
5129  }
5130 
5131  /* Make a temporary context to hold all the junk */
5132  if (subcontext)
5133  arr_context = AllocSetContextCreate(rcontext,
5134  "accumArrayResultArr",
5135  ALLOCSET_DEFAULT_MINSIZE,
5136  ALLOCSET_DEFAULT_INITSIZE,
5137  ALLOCSET_DEFAULT_MAXSIZE);
5138 
5139  /* Note we initialize all fields to zero */
5140  astate = (ArrayBuildStateArr *)
5141  MemoryContextAllocZero(arr_context, sizeof(ArrayBuildStateArr));
5142  astate->mcontext = arr_context;
5143  astate->private_cxt = subcontext;
5144 
5145  /* Save relevant datatype information */
5146  astate->array_type = array_type;
5147  astate->element_type = element_type;
5148 
5149  return astate;
5150 }
5151 
5152 /*
5153  * accumArrayResultArr - accumulate one (more) sub-array for an array result
5154  *
5155  * astate is working state (can be NULL on first call)
5156  * dvalue/disnull represent the new sub-array to append to the array
5157  * array_type is the array type (must be a valid varlena array type)
5158  * rcontext is where to keep working state
5159  */
5160 ArrayBuildStateArr *
5161 accumArrayResultArr(ArrayBuildStateArr *astate,
5162  Datum dvalue, bool disnull,
5163  Oid array_type,
5164  MemoryContext rcontext)
5165 {
5166  ArrayType *arg;
5167  MemoryContext oldcontext;
5168  int *dims,
5169  *lbs,
5170  ndims,
5171  nitems,
5172  ndatabytes;
5173  char *data;
5174  int i;
5175 
5176  /*
5177  * We disallow accumulating null subarrays. Another plausible definition
5178  * is to ignore them, but callers that want that can just skip calling
5179  * this function.
5180  */
5181  if (disnull)
5182  ereport(ERROR,
5183  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5184  errmsg("cannot accumulate null arrays")));
5185 
5186  /* Detoast input array in caller's context */
5187  arg = DatumGetArrayTypeP(dvalue);
5188 
5189  if (astate == NULL)
5190  astate = initArrayResultArr(array_type, InvalidOid, rcontext, true);
5191  else
5192  Assert(astate->array_type == array_type);
5193 
5194  oldcontext = MemoryContextSwitchTo(astate->mcontext);
5195 
5196  /* Collect this input's dimensions */
5197  ndims = ARR_NDIM(arg);
5198  dims = ARR_DIMS(arg);
5199  lbs = ARR_LBOUND(arg);
5200  data = ARR_DATA_PTR(arg);
5201  nitems = ArrayGetNItems(ndims, dims);
5202  ndatabytes = ARR_SIZE(arg) - ARR_DATA_OFFSET(arg);
5203 
5204  if (astate->ndims == 0)
5205  {
5206  /* First input; check/save the dimensionality info */
5207 
5208  /* Should we allow empty inputs and just produce an empty output? */
5209  if (ndims == 0)
5210  ereport(ERROR,
5211  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5212  errmsg("cannot accumulate empty arrays")));
5213  if (ndims + 1 > MAXDIM)
5214  ereport(ERROR,
5215  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
5216  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
5217  ndims + 1, MAXDIM)));
5218 
5219  /*
5220  * The output array will have n+1 dimensions, with the ones after the
5221  * first matching the input's dimensions.
5222  */
5223  astate->ndims = ndims + 1;
5224  astate->dims[0] = 0;
5225  memcpy(&astate->dims[1], dims, ndims * sizeof(int));
5226  astate->lbs[0] = 1;
5227  memcpy(&astate->lbs[1], lbs, ndims * sizeof(int));
5228 
5229  /* Allocate at least enough data space for this item */
5230  astate->abytes = 1024;
5231  while (astate->abytes <= ndatabytes)
5232  astate->abytes *= 2;
5233  astate->data = (char *) palloc(astate->abytes);
5234  }
5235  else
5236  {
5237  /* Second or later input: must match first input's dimensionality */
5238  if (astate->ndims != ndims + 1)
5239  ereport(ERROR,
5240  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5241  errmsg("cannot accumulate arrays of different dimensionality")));
5242  for (i = 0; i < ndims; i++)
5243  {
5244  if (astate->dims[i + 1] != dims[i] || astate->lbs[i + 1] != lbs[i])
5245  ereport(ERROR,
5246  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5247  errmsg("cannot accumulate arrays of different dimensionality")));
5248  }
5249 
5250  /* Enlarge data space if needed */
5251  if (astate->nbytes + ndatabytes > astate->abytes)
5252  {
5253  astate->abytes = Max(astate->abytes * 2,
5254  astate->nbytes + ndatabytes);
5255  astate->data = (char *) repalloc(astate->data, astate->abytes);
5256  }
5257  }
5258 
5259  /*
5260  * Copy the data portion of the sub-array. Note we assume that the
5261  * advertised data length of the sub-array is properly aligned. We do not
5262  * have to worry about detoasting elements since whatever's in the
5263  * sub-array should be OK already.
5264  */
5265  memcpy(astate->data + astate->nbytes, data, ndatabytes);
5266  astate->nbytes += ndatabytes;
5267 
5268  /* Deal with null bitmap if needed */
5269  if (astate->nullbitmap || ARR_HASNULL(arg))
5270  {
5271  int newnitems = astate->nitems + nitems;
5272 
5273  if (astate->nullbitmap == NULL)
5274  {
5275  /*
5276  * First input with nulls; we must retrospectively handle any
5277  * previous inputs by marking all their items non-null.
5278  */
5279  astate->aitems = 256;
5280  while (astate->aitems <= newnitems)
5281  astate->aitems *= 2;
5282  astate->nullbitmap = (bits8 *) palloc((astate->aitems + 7) / 8);
5283  array_bitmap_copy(astate->nullbitmap, 0,
5284  NULL, 0,
5285  astate->nitems);
5286  }
5287  else if (newnitems > astate->aitems)
5288  {
5289  astate->aitems = Max(astate->aitems * 2, newnitems);
5290  astate->nullbitmap = (bits8 *)
5291  repalloc(astate->nullbitmap, (astate->aitems + 7) / 8);
5292  }
5293  array_bitmap_copy(astate->nullbitmap, astate->nitems,
5294  ARR_NULLBITMAP(arg), 0,
5295  nitems);
5296  }
5297 
5298  astate->nitems += nitems;
5299  astate->dims[0] += 1;
5300 
5301  MemoryContextSwitchTo(oldcontext);
5302 
5303  /* Release detoasted copy if any */
5304  if ((Pointer) arg != DatumGetPointer(dvalue))
5305  pfree(arg);
5306 
5307  return astate;
5308 }
5309 
5310 /*
5311  * makeArrayResultArr - produce N+1-D final result of accumArrayResultArr
5312  *
5313  * astate is working state (must not be NULL)
5314  * rcontext is where to construct result
5315  * release is true if okay to release working state
5316  */
5317 Datum
5318 makeArrayResultArr(ArrayBuildStateArr *astate,
5319  MemoryContext rcontext,
5320  bool release)
5321 {
5322  ArrayType *result;
5323  MemoryContext oldcontext;
5324 
5325  /* Build the final array result in rcontext */
5326  oldcontext = MemoryContextSwitchTo(rcontext);
5327 
5328  if (astate->ndims == 0)
5329  {
5330  /* No inputs, return empty array */
5331  result = construct_empty_array(astate->element_type);
5332  }
5333  else
5334  {
5335  int dataoffset,
5336  nbytes;
5337 
5338  /* Compute required space */
5339  nbytes = astate->nbytes;
5340  if (astate->nullbitmap != NULL)
5341  {
5342  dataoffset = ARR_OVERHEAD_WITHNULLS(astate->ndims, astate->nitems);
5343  nbytes += dataoffset;
5344  }
5345  else
5346  {
5347  dataoffset = 0;
5348  nbytes += ARR_OVERHEAD_NONULLS(astate->ndims);
5349  }
5350 
5351  result = (ArrayType *) palloc0(nbytes);
5352  SET_VARSIZE(result, nbytes);
5353  result->ndim = astate->ndims;
5354  result->dataoffset = dataoffset;
5355  result->elemtype = astate->element_type;
5356 
5357  memcpy(ARR_DIMS(result), astate->dims, astate->ndims * sizeof(int));
5358  memcpy(ARR_LBOUND(result), astate->lbs, astate->ndims * sizeof(int));
5359  memcpy(ARR_DATA_PTR(result), astate->data, astate->nbytes);
5360 
5361  if (astate->nullbitmap != NULL)
5362  array_bitmap_copy(ARR_NULLBITMAP(result), 0,
5363  astate->nullbitmap, 0,
5364  astate->nitems);
5365  }
5366 
5367  MemoryContextSwitchTo(oldcontext);
5368 
5369  /* Clean up all the junk */
5370  if (release)
5371  {
5372  Assert(astate->private_cxt);
5373  MemoryContextDelete(astate->mcontext);
5374  }
5375 
5376  return PointerGetDatum(result);
5377 }
5378 
5379 /*
5380  * The following three functions provide essentially the same API as
5381  * initArrayResult/accumArrayResult/makeArrayResult, but can accept either
5382  * scalar or array inputs, invoking the appropriate set of functions above.
5383  */
5384 
5385 /*
5386  * initArrayResultAny - initialize an empty ArrayBuildStateAny
5387  *
5388  * input_type is the input datatype (either element or array type)
5389  * rcontext is where to keep working state
5390  * subcontext is a flag determining whether to use a separate memory context
5391  */
5392 ArrayBuildStateAny *
5393 initArrayResultAny(Oid input_type, MemoryContext rcontext, bool subcontext)
5394 {
5395  ArrayBuildStateAny *astate;
5396  Oid element_type = get_element_type(input_type);
5397 
5398  if (OidIsValid(element_type))
5399  {
5400  /* Array case */
5401  ArrayBuildStateArr *arraystate;
5402 
5403  arraystate = initArrayResultArr(input_type, InvalidOid, rcontext, subcontext);
5404  astate = (ArrayBuildStateAny *)
5405  MemoryContextAlloc(arraystate->mcontext,
5406  sizeof(ArrayBuildStateAny));
5407  astate->scalarstate = NULL;
5408  astate->arraystate = arraystate;
5409  }
5410  else
5411  {
5412  /* Scalar case */
5413  ArrayBuildState *scalarstate;
5414 
5415  /* Let's just check that we have a type that can be put into arrays */
5416  Assert(OidIsValid(get_array_type(input_type)));
5417 
5418  scalarstate = initArrayResult(input_type, rcontext, subcontext);
5419  astate = (ArrayBuildStateAny *)
5420  MemoryContextAlloc(scalarstate->mcontext,
5421  sizeof(ArrayBuildStateAny));
5422  astate->scalarstate = scalarstate;
5423  astate->arraystate = NULL;
5424  }
5425 
5426  return astate;
5427 }
5428 
5429 /*
5430  * accumArrayResultAny - accumulate one (more) input for an array result
5431  *
5432  * astate is working state (can be NULL on first call)
5433  * dvalue/disnull represent the new input to append to the array
5434  * input_type is the input datatype (either element or array type)
5435  * rcontext is where to keep working state
5436  */
5437 ArrayBuildStateAny *
5438 accumArrayResultAny(ArrayBuildStateAny *astate,
5439  Datum dvalue, bool disnull,
5440  Oid input_type,
5441  MemoryContext rcontext)
5442 {
5443  if (astate == NULL)
5444  astate = initArrayResultAny(input_type, rcontext, true);
5445 
5446  if (astate->scalarstate)
5447  (void) accumArrayResult(astate->scalarstate,
5448  dvalue, disnull,
5449  input_type, rcontext);
5450  else
5451  (void) accumArrayResultArr(astate->arraystate,
5452  dvalue, disnull,
5453  input_type, rcontext);
5454 
5455  return astate;
5456 }
5457 
5458 /*
5459  * makeArrayResultAny - produce final result of accumArrayResultAny
5460  *
5461  * astate is working state (must not be NULL)
5462  * rcontext is where to construct result
5463  * release is true if okay to release working state
5464  */
5465 Datum
5466 makeArrayResultAny(ArrayBuildStateAny *astate,
5467  MemoryContext rcontext, bool release)
5468 {
5469  Datum result;
5470 
5471  if (astate->scalarstate)
5472  {
5473  /* Must use makeMdArrayResult to support "release" parameter */
5474  int ndims;
5475  int dims[1];
5476  int lbs[1];
5477 
5478  /* If no elements were presented, we want to create an empty array */
5479  ndims = (astate->scalarstate->nelems > 0) ? 1 : 0;
5480  dims[0] = astate->scalarstate->nelems;
5481  lbs[0] = 1;
5482 
5483  result = makeMdArrayResult(astate->scalarstate, ndims, dims, lbs,
5484  rcontext, release);
5485  }
5486  else
5487  {
5488  result = makeArrayResultArr(astate->arraystate,
5489  rcontext, release);
5490  }
5491  return result;
5492 }
5493 
5494 
5495 Datum
5496 array_larger(PG_FUNCTION_ARGS)
5497 {
5498  if (array_cmp(fcinfo) > 0)
5499  PG_RETURN_DATUM(PG_GETARG_DATUM(0));
5500  else
5501  PG_RETURN_DATUM(PG_GETARG_DATUM(1));
5502 }
5503 
5504 Datum
5505 array_smaller(PG_FUNCTION_ARGS)
5506 {
5507  if (array_cmp(fcinfo) < 0)
5508  PG_RETURN_DATUM(PG_GETARG_DATUM(0));
5509  else
5510  PG_RETURN_DATUM(PG_GETARG_DATUM(1));
5511 }
5512 
5513 
5514 typedef struct generate_subscripts_fctx
5515 {
5516  int32 lower;
5517  int32 upper;
5518  bool reverse;
5519 } generate_subscripts_fctx;
5520 
5521 /*
5522  * generate_subscripts(array anyarray, dim int [, reverse bool])
5523  * Returns all subscripts of the array for any dimension
5524  */
5525 Datum
5526 generate_subscripts(PG_FUNCTION_ARGS)
5527 {
5528  FuncCallContext *funcctx;
5529  MemoryContext oldcontext;
5530  generate_subscripts_fctx *fctx;
5531 
5532  /* stuff done only on the first call of the function */
5533  if (SRF_IS_FIRSTCALL())
5534  {
5535  AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
5536  int reqdim = PG_GETARG_INT32(1);
5537  int *lb,
5538  *dimv;
5539 
5540  /* create a function context for cross-call persistence */
5541  funcctx = SRF_FIRSTCALL_INIT();
5542 
5543  /* Sanity check: does it look like an array at all? */
5544  if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
5545  SRF_RETURN_DONE(funcctx);
5546 
5547  /* Sanity check: was the requested dim valid */
5548  if (reqdim <= 0 || reqdim > AARR_NDIM(v))
5549  SRF_RETURN_DONE(funcctx);
5550 
5551  /*
5552  * switch to memory context appropriate for multiple function calls
5553  */
5554  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
5555  fctx = (generate_subscripts_fctx *) palloc(sizeof(generate_subscripts_fctx));
5556 
5557  lb = AARR_LBOUND(v);
5558  dimv = AARR_DIMS(v);
5559 
5560  fctx->lower = lb[reqdim - 1];
5561  fctx->upper = dimv[reqdim - 1] + lb[reqdim - 1] - 1;
5562  fctx->reverse = (PG_NARGS() < 3) ? false : PG_GETARG_BOOL(2);
5563 
5564  funcctx->user_fctx = fctx;
5565 
5566  MemoryContextSwitchTo(oldcontext);
5567  }
5568 
5569  funcctx = SRF_PERCALL_SETUP();
5570 
5571  fctx = funcctx->user_fctx;
5572 
5573  if (fctx->lower <= fctx->upper)
5574  {
5575  if (!fctx->reverse)
5576  SRF_RETURN_NEXT(funcctx, Int32GetDatum(fctx->lower++));
5577  else
5578  SRF_RETURN_NEXT(funcctx, Int32GetDatum(fctx->upper--));
5579  }
5580  else
5581  /* done when there are no more elements left */
5582  SRF_RETURN_DONE(funcctx);
5583 }
5584 
5585 /*
5586  * generate_subscripts_nodir
5587  * Implements the 2-argument version of generate_subscripts
5588  */
5589 Datum
5590 generate_subscripts_nodir(PG_FUNCTION_ARGS)
5591 {
5592  /* just call the other one -- it can handle both cases */
5593  return generate_subscripts(fcinfo);
5594 }
5595 
5596 /*
5597  * array_fill_with_lower_bounds
5598  * Create and fill array with defined lower bounds.
5599  */
5600 Datum
5601 array_fill_with_lower_bounds(PG_FUNCTION_ARGS)
5602 {
5603  ArrayType *dims;
5604  ArrayType *lbs;
5605  ArrayType *result;
5606  Oid elmtype;
5607  Datum value;
5608  bool isnull;
5609 
5610  if (PG_ARGISNULL(1) || PG_ARGISNULL(2))
5611  ereport(ERROR,
5612  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5613  errmsg("dimension array or low bound array cannot be null")));
5614 
5615  dims = PG_GETARG_ARRAYTYPE_P(1);
5616  lbs = PG_GETARG_ARRAYTYPE_P(2);
5617 
5618  if (!PG_ARGISNULL(0))
5619  {
5620  value = PG_GETARG_DATUM(0);
5621  isnull = false;
5622  }
5623  else
5624  {
5625  value = 0;
5626  isnull = true;
5627  }
5628 
5629  elmtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
5630  if (!OidIsValid(elmtype))
5631  elog(ERROR, "could not determine data type of input");
5632 
5633  result = array_fill_internal(dims, lbs, value, isnull, elmtype, fcinfo);
5634  PG_RETURN_ARRAYTYPE_P(result);
5635 }
5636 
5637 /*
5638  * array_fill
5639  * Create and fill array with default lower bounds.
5640  */
5641 Datum
5642 array_fill(PG_FUNCTION_ARGS)
5643 {
5644  ArrayType *dims;
5645  ArrayType *result;
5646  Oid elmtype;
5647  Datum value;
5648  bool isnull;
5649 
5650  if (PG_ARGISNULL(1))
5651  ereport(ERROR,
5652  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5653  errmsg("dimension array or low bound array cannot be null")));
5654 
5655  dims = PG_GETARG_ARRAYTYPE_P(1);
5656 
5657  if (!PG_ARGISNULL(0))
5658  {
5659  value = PG_GETARG_DATUM(0);
5660  isnull = false;
5661  }
5662  else
5663  {
5664  value = 0;
5665  isnull = true;
5666  }
5667 
5668  elmtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
5669  if (!OidIsValid(elmtype))
5670  elog(ERROR, "could not determine data type of input");
5671 
5672  result = array_fill_internal(dims, NULL, value, isnull, elmtype, fcinfo);
5673  PG_RETURN_ARRAYTYPE_P(result);
5674 }
5675 
5676 static ArrayType *
5677 create_array_envelope(int ndims, int *dimv, int *lbsv, int nbytes,
5678  Oid elmtype, int dataoffset)
5679 {
5680  ArrayType *result;
5681 
5682  result = (ArrayType *) palloc0(nbytes);
5683  SET_VARSIZE(result, nbytes);
5684  result->ndim = ndims;
5685  result->dataoffset = dataoffset;
5686  result->elemtype = elmtype;
5687  memcpy(ARR_DIMS(result), dimv, ndims * sizeof(int));
5688  memcpy(ARR_LBOUND(result), lbsv, ndims * sizeof(int));
5689 
5690  return result;
5691 }
5692 
5693 static ArrayType *
5694 array_fill_internal(ArrayType *dims, ArrayType *lbs,
5695  Datum value, bool isnull, Oid elmtype,
5696  FunctionCallInfo fcinfo)
5697 {
5698  ArrayType *result;
5699  int *dimv;
5700  int *lbsv;
5701  int ndims;
5702  int nitems;
5703  int deflbs[MAXDIM];
5704  int16 elmlen;
5705  bool elmbyval;
5706  char elmalign;
5707  ArrayMetaState *my_extra;
5708 
5709  /*
5710  * Params checks
5711  */
5712  if (ARR_NDIM(dims) != 1)
5713  ereport(ERROR,
5714  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5715  errmsg("wrong number of array subscripts"),
5716  errdetail("Dimension array must be one dimensional.")));
5717 
5718  if (ARR_LBOUND(dims)[0] != 1)
5719  ereport(ERROR,
5720  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5721  errmsg("wrong range of array subscripts"),
5722  errdetail("Lower bound of dimension array must be one.")));
5723 
5724  if (array_contains_nulls(dims))
5725  ereport(ERROR,
5726  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5727  errmsg("dimension values cannot be null")));
5728 
5729  dimv = (int *) ARR_DATA_PTR(dims);
5730  ndims = ARR_DIMS(dims)[0];
5731 
5732  if (ndims < 0) /* we do allow zero-dimension arrays */
5733  ereport(ERROR,
5734  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5735  errmsg("invalid number of dimensions: %d", ndims)));
5736  if (ndims > MAXDIM)
5737  ereport(ERROR,
5738  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
5739  errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",
5740  ndims, MAXDIM)));
5741 
5742  if (lbs != NULL)
5743  {
5744  if (ARR_NDIM(lbs) != 1)
5745  ereport(ERROR,
5746  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5747  errmsg("wrong number of array subscripts"),
5748  errdetail("Dimension array must be one dimensional.")));
5749 
5750  if (ARR_LBOUND(lbs)[0] != 1)
5751  ereport(ERROR,
5752  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5753  errmsg("wrong range of array subscripts"),
5754  errdetail("Lower bound of dimension array must be one.")));
5755 
5756  if (array_contains_nulls(lbs))
5757  ereport(ERROR,
5758  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5759  errmsg("dimension values cannot be null")));
5760 
5761  if (ARR_DIMS(lbs)[0] != ndims)
5762  ereport(ERROR,
5763  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5764  errmsg("wrong number of array subscripts"),
5765  errdetail("Low bound array has different size than dimensions array.")));
5766 
5767  lbsv = (int *) ARR_DATA_PTR(lbs);
5768  }
5769  else
5770  {
5771  int i;
5772 
5773  for (i = 0; i < MAXDIM; i++)
5774  deflbs[i] = 1;
5775 
5776  lbsv = deflbs;
5777  }
5778 
5779  /* fast track for empty array */
5780  if (ndims == 0)
5781  return construct_empty_array(elmtype);
5782 
5783  nitems = ArrayGetNItems(ndims, dimv);
5784 
5785  /*
5786  * We arrange to look up info about element type only once per series of
5787  * calls, assuming the element type doesn't change underneath us.
5788  */
5789  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
5790  if (my_extra == NULL)
5791  {
5792  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
5793  sizeof(ArrayMetaState));
5794  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
5795  my_extra->element_type = InvalidOid;
5796  }
5797 
5798  if (my_extra->element_type != elmtype)
5799  {
5800  /* Get info about element type */
5801  get_typlenbyvalalign(elmtype,
5802  &my_extra->typlen,
5803  &my_extra->typbyval,
5804  &my_extra->typalign);
5805  my_extra->element_type = elmtype;
5806  }
5807 
5808  elmlen = my_extra->typlen;
5809  elmbyval = my_extra->typbyval;
5810  elmalign = my_extra->typalign;
5811 
5812  /* compute required space */
5813  if (!isnull)
5814  {
5815  int i;
5816  char *p;
5817  int nbytes;
5818  int totbytes;
5819 
5820  /* make sure data is not toasted */
5821  if (elmlen == -1)
5822  value = PointerGetDatum(PG_DETOAST_DATUM(value));
5823 
5824  nbytes = att_addlength_datum(0, elmlen, value);
5825  nbytes = att_align_nominal(nbytes, elmalign);
5826  Assert(nbytes > 0);
5827 
5828  totbytes = nbytes * nitems;
5829 
5830  /* check for overflow of multiplication or total request */
5831  if (totbytes / nbytes != nitems ||
5832  !AllocSizeIsValid(totbytes))
5833  ereport(ERROR,
5834  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
5835  errmsg("array size exceeds the maximum allowed (%d)",
5836  (int) MaxAllocSize)));
5837 
5838  /*
5839  * This addition can't overflow, but it might cause us to go past
5840  * MaxAllocSize. We leave it to palloc to complain in that case.
5841  */
5842  totbytes += ARR_OVERHEAD_NONULLS(ndims);
5843 
5844  result = create_array_envelope(ndims, dimv, lbsv, totbytes,
5845  elmtype, 0);
5846 
5847  p = ARR_DATA_PTR(result);
5848  for (i = 0; i < nitems; i++)
5849  p += ArrayCastAndSet(value, elmlen, elmbyval, elmalign, p);
5850  }
5851  else
5852  {
5853  int nbytes;
5854  int dataoffset;
5855 
5856  dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
5857  nbytes = dataoffset;
5858 
5859  result = create_array_envelope(ndims, dimv, lbsv, nbytes,
5860  elmtype, dataoffset);
5861 
5862  /* create_array_envelope already zeroed the bitmap, so we're done */
5863  }
5864 
5865  return result;
5866 }
5867 
5868 
5869 /*
5870  * UNNEST
5871  */
5872 Datum
5873 array_unnest(PG_FUNCTION_ARGS)
5874 {
5875  typedef struct
5876  {
5877  array_iter iter;
5878  int nextelem;
5879  int numelems;
5880  int16 elmlen;
5881  bool elmbyval;
5882  char elmalign;
5883  } array_unnest_fctx;
5884 
5885  FuncCallContext *funcctx;
5886  array_unnest_fctx *fctx;
5887  MemoryContext oldcontext;
5888 
5889  /* stuff done only on the first call of the function */
5890  if (SRF_IS_FIRSTCALL())
5891  {
5892  AnyArrayType *arr;
5893 
5894  /* create a function context for cross-call persistence */
5895  funcctx = SRF_FIRSTCALL_INIT();
5896 
5897  /*
5898  * switch to memory context appropriate for multiple function calls
5899  */
5900  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
5901 
5902  /*
5903  * Get the array value and detoast if needed. We can't do this
5904  * earlier because if we have to detoast, we want the detoasted copy
5905  * to be in multi_call_memory_ctx, so it will go away when we're done
5906  * and not before. (If no detoast happens, we assume the originally
5907  * passed array will stick around till then.)
5908  */
5909  arr = PG_GETARG_ANY_ARRAY(0);
5910 
5911  /* allocate memory for user context */
5912  fctx = (array_unnest_fctx *) palloc(sizeof(array_unnest_fctx));
5913 
5914  /* initialize state */
5915  array_iter_setup(&fctx->iter, arr);
5916  fctx->nextelem = 0;
5917  fctx->numelems = ArrayGetNItems(AARR_NDIM(arr), AARR_DIMS(arr));
5918 
5919  if (VARATT_IS_EXPANDED_HEADER(arr))
5920  {
5921  /* we can just grab the type data from expanded array */
5922  fctx->elmlen = arr->xpn.typlen;
5923  fctx->elmbyval = arr->xpn.typbyval;
5924  fctx->elmalign = arr->xpn.typalign;
5925  }
5926  else
5927  get_typlenbyvalalign(AARR_ELEMTYPE(arr),
5928  &fctx->elmlen,
5929  &fctx->elmbyval,
5930  &fctx->elmalign);
5931 
5932  funcctx->user_fctx = fctx;
5933  MemoryContextSwitchTo(oldcontext);
5934  }
5935 
5936  /* stuff done on every call of the function */
5937  funcctx = SRF_PERCALL_SETUP();
5938  fctx = funcctx->user_fctx;
5939 
5940  if (fctx->nextelem < fctx->numelems)
5941  {
5942  int offset = fctx->nextelem++;
5943  Datum elem;
5944 
5945  elem = array_iter_next(&fctx->iter, &fcinfo->isnull, offset,
5946  fctx->elmlen, fctx->elmbyval, fctx->elmalign);
5947 
5948  SRF_RETURN_NEXT(funcctx, elem);
5949  }
5950  else
5951  {
5952  /* do when there is no more left */
5953  SRF_RETURN_DONE(funcctx);
5954  }
5955 }
5956 
5957 
5958 /*
5959  * array_replace/array_remove support
5960  *
5961  * Find all array entries matching (not distinct from) search/search_isnull,
5962  * and delete them if remove is true, else replace them with
5963  * replace/replace_isnull. Comparisons are done using the specified
5964  * collation. fcinfo is passed only for caching purposes.
5965  */
5966 static ArrayType *
5967 array_replace_internal(ArrayType *array,
5968  Datum search, bool search_isnull,
5969  Datum replace, bool replace_isnull,
5970  bool remove, Oid collation,
5971  FunctionCallInfo fcinfo)
5972 {
5973  ArrayType *result;
5974  Oid element_type;
5975  Datum *values;
5976  bool *nulls;
5977  int *dim;
5978  int ndim;
5979  int nitems,
5980  nresult;
5981  int i;
5982  int32 nbytes = 0;
5983  int32 dataoffset;
5984  bool hasnulls;
5985  int typlen;
5986  bool typbyval;
5987  char typalign;
5988  char *arraydataptr;
5989  bits8 *bitmap;
5990  int bitmask;
5991  bool changed = false;
5992  TypeCacheEntry *typentry;
5993  FunctionCallInfoData locfcinfo;
5994 
5995  element_type = ARR_ELEMTYPE(array);
5996  ndim = ARR_NDIM(array);
5997  dim = ARR_DIMS(array);
5998  nitems = ArrayGetNItems(ndim, dim);
5999 
6000  /* Return input array unmodified if it is empty */
6001  if (nitems <= 0)
6002  return array;
6003 
6004  /*
6005  * We can't remove elements from multi-dimensional arrays, since the
6006  * result might not be rectangular.
6007  */
6008  if (remove && ndim > 1)
6009  ereport(ERROR,
6010  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
6011  errmsg("removing elements from multidimensional arrays is not supported")));
6012 
6013  /*
6014  * We arrange to look up the equality function only once per series of
6015  * calls, assuming the element type doesn't change underneath us.
6016  */
6017  typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
6018  if (typentry == NULL ||
6019  typentry->type_id != element_type)
6020  {
6021  typentry = lookup_type_cache(element_type,
6022  TYPECACHE_EQ_OPR_FINFO);
6023  if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
6024  ereport(ERROR,
6025  (errcode(ERRCODE_UNDEFINED_FUNCTION),
6026  errmsg("could not identify an equality operator for type %s",
6027  format_type_be(element_type))));
6028  fcinfo->flinfo->fn_extra = (void *) typentry;
6029  }
6030  typlen = typentry->typlen;
6031  typbyval = typentry->typbyval;
6032  typalign = typentry->typalign;
6033 
6034  /*
6035  * Detoast values if they are toasted. The replacement value must be
6036  * detoasted for insertion into the result array, while detoasting the
6037  * search value only once saves cycles.
6038  */
6039  if (typlen == -1)
6040  {
6041  if (!search_isnull)
6042  search = PointerGetDatum(PG_DETOAST_DATUM(search));
6043  if (!replace_isnull)
6044  replace = PointerGetDatum(PG_DETOAST_DATUM(replace));
6045  }
6046 
6047  /* Prepare to apply the comparison operator */
6048  InitFunctionCallInfoData(locfcinfo, &typentry->eq_opr_finfo, 2,
6049  collation, NULL, NULL);
6050 
6051  /* Allocate temporary arrays for new values */
6052  values = (Datum *) palloc(nitems * sizeof(Datum));
6053  nulls = (bool *) palloc(nitems * sizeof(bool));
6054 
6055  /* Loop over source data */
6056  arraydataptr = ARR_DATA_PTR(array);
6057  bitmap = ARR_NULLBITMAP(array);
6058  bitmask = 1;
6059  hasnulls = false;
6060  nresult = 0;
6061 
6062  for (i = 0; i < nitems; i++)
6063  {
6064  Datum elt;
6065  bool isNull;
6066  bool oprresult;
6067  bool skip = false;
6068 
6069  /* Get source element, checking for NULL */
6070  if (bitmap && (*bitmap & bitmask) == 0)
6071  {
6072  isNull = true;
6073  /* If searching for NULL, we have a match */
6074  if (search_isnull)
6075  {
6076  if (remove)
6077  {
6078  skip = true;
6079  changed = true;
6080  }
6081  else if (!replace_isnull)
6082  {
6083  values[nresult] = replace;
6084  isNull = false;
6085  changed = true;
6086  }
6087  }
6088  }
6089  else
6090  {
6091  isNull = false;
6092  elt = fetch_att(arraydataptr, typbyval, typlen);
6093  arraydataptr = att_addlength_datum(arraydataptr, typlen, elt);
6094  arraydataptr = (char *) att_align_nominal(arraydataptr, typalign);
6095 
6096  if (search_isnull)
6097  {
6098  /* no match possible, keep element */
6099  values[nresult] = elt;
6100  }
6101  else
6102  {
6103  /*
6104  * Apply the operator to the element pair
6105  */
6106  locfcinfo.arg[0] = elt;
6107  locfcinfo.arg[1] = search;
6108  locfcinfo.argnull[0] = false;
6109  locfcinfo.argnull[1] = false;
6110  locfcinfo.isnull = false;
6111  oprresult = DatumGetBool(FunctionCallInvoke(&locfcinfo));
6112  if (!oprresult)
6113  {
6114  /* no match, keep element */
6115  values[nresult] = elt;
6116  }
6117  else
6118  {
6119  /* match, so replace or delete */
6120  changed = true;
6121  if (remove)
6122  skip = true;
6123  else
6124  {
6125  values[nresult] = replace;
6126  isNull = replace_isnull;
6127  }
6128  }
6129  }
6130  }
6131 
6132  if (!skip)
6133  {
6134  nulls[nresult] = isNull;
6135  if (isNull)
6136  hasnulls = true;
6137  else
6138  {
6139  /* Update total result size */
6140  nbytes = att_addlength_datum(nbytes, typlen, values[nresult]);
6141  nbytes = att_align_nominal(nbytes, typalign);
6142  /* check for overflow of total request */
6143  if (!AllocSizeIsValid(nbytes))
6144  ereport(ERROR,
6145  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
6146  errmsg("array size exceeds the maximum allowed (%d)",
6147  (int) MaxAllocSize)));
6148  }
6149  nresult++;
6150  }
6151 
6152  /* advance bitmap pointer if any */
6153  if (bitmap)
6154  {
6155  bitmask <<= 1;
6156  if (bitmask == 0x100)
6157  {
6158  bitmap++;
6159  bitmask = 1;
6160  }
6161  }
6162  }
6163 
6164  /*
6165  * If not changed just return the original array
6166  */
6167  if (!changed)
6168  {
6169  pfree(values);
6170  pfree(nulls);
6171  return array;
6172  }
6173 
6174  /* If all elements were removed return an empty array */
6175  if (nresult == 0)
6176  {
6177  pfree(values);
6178  pfree(nulls);
6179  return construct_empty_array(element_type);
6180  }
6181 
6182  /* Allocate and initialize the result array */
6183  if (hasnulls)
6184  {
6185  dataoffset = ARR_OVERHEAD_WITHNULLS(ndim, nresult);
6186  nbytes += dataoffset;
6187  }
6188  else
6189  {
6190  dataoffset = 0; /* marker for no null bitmap */
6191  nbytes += ARR_OVERHEAD_NONULLS(ndim);
6192  }
6193  result = (ArrayType *) palloc0(nbytes);
6194  SET_VARSIZE(result, nbytes);
6195  result->ndim = ndim;
6196  result->dataoffset = dataoffset;
6197  result->elemtype = element_type;
6198  memcpy(ARR_DIMS(result), ARR_DIMS(array), ndim * sizeof(int));
6199  memcpy(ARR_LBOUND(result), ARR_LBOUND(array), ndim * sizeof(int));
6200 
6201  if (remove)
6202  {
6203  /* Adjust the result length */
6204  ARR_DIMS(result)[0] = nresult;
6205  }
6206 
6207  /* Insert data into result array */
6208  CopyArrayEls(result,
6209  values, nulls, nresult,
6210  typlen, typbyval, typalign,
6211  false);
6212 
6213  pfree(values);
6214  pfree(nulls);
6215 
6216  return result;
6217 }
6218 
6219 /*
6220  * Remove any occurrences of an element from an array
6221  *
6222  * If used on a multi-dimensional array this will raise an error.
6223  */
6224 Datum
6225 array_remove(PG_FUNCTION_ARGS)
6226 {
6227  ArrayType *array;
6228  Datum search = PG_GETARG_DATUM(1);
6229  bool search_isnull = PG_ARGISNULL(1);
6230 
6231  if (PG_ARGISNULL(0))
6232  PG_RETURN_NULL();
6233  array = PG_GETARG_ARRAYTYPE_P(0);
6234 
6235  array = array_replace_internal(array,
6236  search, search_isnull,
6237  (Datum) 0, true,
6238  true, PG_GET_COLLATION(),
6239  fcinfo);
6240  PG_RETURN_ARRAYTYPE_P(array);
6241 }
6242 
6243 /*
6244  * Replace any occurrences of an element in an array
6245  */
6246 Datum
6247 array_replace(PG_FUNCTION_ARGS)
6248 {
6249  ArrayType *array;
6250  Datum search = PG_GETARG_DATUM(1);
6251  bool search_isnull = PG_ARGISNULL(1);
6252  Datum replace = PG_GETARG_DATUM(2);
6253  bool replace_isnull = PG_ARGISNULL(2);
6254 
6255  if (PG_ARGISNULL(0))
6256  PG_RETURN_NULL();
6257  array = PG_GETARG_ARRAYTYPE_P(0);
6258 
6259  array = array_replace_internal(array,
6260  search, search_isnull,
6261  replace, replace_isnull,
6262  false, PG_GET_COLLATION(),
6263  fcinfo);
6264  PG_RETURN_ARRAYTYPE_P(array);
6265 }
6266 
6267 /*
6268  * Implements width_bucket(anyelement, anyarray).
6269  *
6270  * 'thresholds' is an array containing lower bound values for each bucket;
6271  * these must be sorted from smallest to largest, or bogus results will be
6272  * produced. If N thresholds are supplied, the output is from 0 to N:
6273  * 0 is for inputs < first threshold, N is for inputs >= last threshold.
6274  */
6275 Datum
6276 width_bucket_array(PG_FUNCTION_ARGS)
6277 {
6278  Datum operand = PG_GETARG_DATUM(0);
6279  ArrayType *thresholds = PG_GETARG_ARRAYTYPE_P(1);
6280  Oid collation = PG_GET_COLLATION();
6281  Oid element_type = ARR_ELEMTYPE(thresholds);
6282  int result;
6283 
6284  /* Check input */
6285  if (ARR_NDIM(thresholds) > 1)
6286  ereport(ERROR,
6287  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
6288  errmsg("thresholds must be one-dimensional array")));
6289 
6290  if (array_contains_nulls(thresholds))
6291  ereport(ERROR,
6292  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
6293  errmsg("thresholds array must not contain NULLs")));
6294 
6295  /* We have a dedicated implementation for float8 data */
6296  if (element_type == FLOAT8OID)
6297  result = width_bucket_array_float8(operand, thresholds);
6298  else
6299  {
6300  TypeCacheEntry *typentry;
6301 
6302  /* Cache information about the input type */
6303  typentry = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
6304  if (typentry == NULL ||
6305  typentry->type_id != element_type)
6306  {
6307  typentry = lookup_type_cache(element_type,
6308  TYPECACHE_CMP_PROC_FINFO);
6309  if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
6310  ereport(ERROR,
6311  (errcode(ERRCODE_UNDEFINED_FUNCTION),
6312  errmsg("could not identify a comparison function for type %s",
6313  format_type_be(element_type))));
6314  fcinfo->flinfo->fn_extra = (void *) typentry;
6315  }
6316 
6317  /*
6318  * We have separate implementation paths for fixed- and variable-width
6319  * types, since indexing the array is a lot cheaper in the first case.
6320  */
6321  if (typentry->typlen > 0)
6322  result = width_bucket_array_fixed(operand, thresholds,
6323  collation, typentry);
6324  else
6325  result = width_bucket_array_variable(operand, thresholds,
6326  collation, typentry);
6327  }
6328 
6329  /* Avoid leaking memory when handed toasted input. */
6330  PG_FREE_IF_COPY(thresholds, 1);
6331 
6332  PG_RETURN_INT32(result);
6333 }
6334 
6335 /*
6336  * width_bucket_array for float8 data.
6337  */
6338 static int
6339 width_bucket_array_float8(Datum operand, ArrayType *thresholds)
6340 {
6341  float8 op = DatumGetFloat8(operand);
6342  float8 *thresholds_data;
6343  int left;
6344  int right;
6345 
6346  /*
6347  * Since we know the array contains no NULLs, we can just index it
6348  * directly.
6349  */
6350  thresholds_data = (float8 *) ARR_DATA_PTR(thresholds);
6351 
6352  left = 0;
6353  right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
6354 
6355  /*
6356  * If the probe value is a NaN, it's greater than or equal to all possible
6357  * threshold values (including other NaNs), so we need not search. Note
6358  * that this would give the same result as searching even if the array
6359  * contains multiple NaNs (as long as they're correctly sorted), since the
6360  * loop logic will find the rightmost of multiple equal threshold values.
6361  */
6362  if (isnan(op))
6363  return right;
6364 
6365  /* Find the bucket */
6366  while (left < right)
6367  {
6368  int mid = (left + right) / 2;
6369 
6370  if (isnan(thresholds_data[mid]) || op < thresholds_data[mid])
6371  right = mid;
6372  else
6373  left = mid + 1;
6374  }
6375 
6376  return left;
6377 }
6378 
6379 /*
6380  * width_bucket_array for generic fixed-width data types.
6381  */
6382 static int
6383 width_bucket_array_fixed(Datum operand,
6384  ArrayType *thresholds,
6385  Oid collation,
6386  TypeCacheEntry *typentry)
6387 {
6388  char *thresholds_data;
6389  int typlen = typentry->typlen;
6390  bool typbyval = typentry->typbyval;
6391  FunctionCallInfoData locfcinfo;
6392  int left;
6393  int right;
6394 
6395  /*
6396  * Since we know the array contains no NULLs, we can just index it
6397  * directly.
6398  */
6399  thresholds_data = (char *) ARR_DATA_PTR(thresholds);
6400 
6401  InitFunctionCallInfoData(locfcinfo, &typentry->cmp_proc_finfo, 2,
6402  collation, NULL, NULL);
6403 
6404  /* Find the bucket */
6405  left = 0;
6406  right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
6407  while (left < right)
6408  {
6409  int mid = (left + right) / 2;
6410  char *ptr;
6411  int32 cmpresult;
6412 
6413  ptr = thresholds_data + mid * typlen;
6414 
6415  locfcinfo.arg[0] = operand;
6416  locfcinfo.arg[1] = fetch_att(ptr, typbyval, typlen);
6417  locfcinfo.argnull[0] = false;
6418  locfcinfo.argnull[1] = false;
6419  locfcinfo.isnull = false;
6420 
6421  cmpresult = DatumGetInt32(FunctionCallInvoke(&locfcinfo));
6422 
6423  if (cmpresult < 0)
6424  right = mid;
6425  else
6426  left = mid + 1;
6427  }
6428 
6429  return left;
6430 }
6431 
6432 /*
6433  * width_bucket_array for generic variable-width data types.
6434  */
6435 static int
6436 width_bucket_array_variable(Datum operand,
6437  ArrayType *thresholds,
6438  Oid collation,
6439  TypeCacheEntry *typentry)
6440 {
6441  char *thresholds_data;
6442  int typlen = typentry->typlen;
6443  bool typbyval = typentry->typbyval;
6444  char typalign = typentry->typalign;
6445  FunctionCallInfoData locfcinfo;
6446  int left;
6447  int right;
6448 
6449  thresholds_data = (char *) ARR_DATA_PTR(thresholds);
6450 
6451  InitFunctionCallInfoData(locfcinfo, &typentry->cmp_proc_finfo, 2,
6452  collation, NULL, NULL);
6453 
6454  /* Find the bucket */
6455  left = 0;
6456  right = ArrayGetNItems(ARR_NDIM(thresholds), ARR_DIMS(thresholds));
6457  while (left < right)
6458  {
6459  int mid = (left + right) / 2;
6460  char *ptr;
6461  int i;
6462  int32 cmpresult;
6463 
6464  /* Locate mid'th array element by advancing from left element */
6465  ptr = thresholds_data;
6466  for (i = left; i < mid; i++)
6467  {
6468  ptr = att_addlength_pointer(ptr, typlen, ptr);
6469  ptr = (char *) att_align_nominal(ptr, typalign);
6470  }
6471 
6472  locfcinfo.arg[0] = operand;
6473  locfcinfo.arg[1] = fetch_att(ptr, typbyval, typlen);
6474  locfcinfo.argnull[0] = false;
6475  locfcinfo.argnull[1] = false;
6476  locfcinfo.isnull = false;
6477 
6478  cmpresult = DatumGetInt32(FunctionCallInvoke(&locfcinfo));
6479 
6480  if (cmpresult < 0)
6481  right = mid;
6482  else
6483  {
6484  left = mid + 1;
6485 
6486  /*
6487  * Move the thresholds pointer to match new "left" index, so we
6488  * don't have to seek over those elements again. This trick
6489  * ensures we do only O(N) array indexing work, not O(N^2).
6490  */
6491  ptr = att_addlength_pointer(ptr, typlen, ptr);
6492  thresholds_data = (char *) att_align_nominal(ptr, typalign);
6493  }
6494  }
6495 
6496  return left;
6497 }
btarraycmp
Datum btarraycmp(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:3719
ArrayIteratorData::nullbitmap
bits8 * nullbitmap
Definition: arrayfuncs.c:70
int16
signed short int16
Definition: c.h:241
generate_subscripts
Datum generate_subscripts(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:5526
DatumGetUInt32
#define DatumGetUInt32(X)
Definition: postgres.h:494
array_create_iterator
ArrayIterator array_create_iterator(ArrayType *arr, int slice_ndim, ArrayMetaState *mstate)
Definition: arrayfuncs.c:4226
makeArrayResultArr
Datum makeArrayResultArr(ArrayBuildStateArr *astate, MemoryContext rcontext, bool release)
Definition: arrayfuncs.c:5318
makeMdArrayResult
Datum makeMdArrayResult(ArrayBuildState *astate, int ndims, int *dims, int *lbs, MemoryContext rcontext, bool release)
Definition: arrayfuncs.c:5060
array_ne
Datum array_ne(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:3689
PG_GETARG_INT32
#define PG_GETARG_INT32(n)
Definition: fmgr.h:225
skip
static void skip(struct vars *v)
Definition: regc_lex.c:1081
FmgrInfo
Definition: fmgr.h:53
MemoryContextDelete
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:203
array_send
Datum array_send(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1534
array_isspace
static bool array_isspace(char ch)
Definition: arrayfuncs.c:431
PG_DETOAST_DATUM_COPY
#define PG_DETOAST_DATUM_COPY(datum)
Definition: fmgr.h:198
array_fill_with_lower_bounds
Datum array_fill_with_lower_bounds(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:5601
array_ge
Datum array_ge(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:3713
VARDATA
#define VARDATA(PTR)
Definition: postgres.h:305
ARR_OVERHEAD_NONULLS
#define ARR_OVERHEAD_NONULLS(ndims)
Definition: array.h:291
initArrayResultAny
ArrayBuildStateAny * initArrayResultAny(Oid input_type, MemoryContext rcontext, bool subcontext)
Definition: arrayfuncs.c:5393
FmgrInfo::fn_mcxt
MemoryContext fn_mcxt
Definition: fmgr.h:62
att_align_nominal
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:144
deconstruct_expanded_array
void deconstruct_expanded_array(ExpandedArrayHeader *eah)
Definition: array_expanded.c:426
ARR_SIZE
#define ARR_SIZE(a)
Definition: array.h:270
VARATT_IS_EXTERNAL_EXPANDED
#define VARATT_IS_EXTERNAL_EXPANDED(PTR)
Definition: postgres.h:325
initArrayResult
ArrayBuildState * initArrayResult(Oid element_type, MemoryContext rcontext, bool subcontext)
Definition: arrayfuncs.c:4922
DatumGetInt32
#define DatumGetInt32(X)
Definition: postgres.h:480
array_map
Datum array_map(FunctionCallInfo fcinfo, Oid retType, ArrayMapState *amstate)
Definition: arrayfuncs.c:3091
array_fill_internal
static ArrayType * array_fill_internal(ArrayType *dims, ArrayType *lbs, Datum value, bool isnull, Oid elmtype, FunctionCallInfo fcinfo)
Definition: arrayfuncs.c:5694
MAXDIM
#define MAXDIM
Definition: c.h:404
array_unnest
Datum array_unnest(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:5873
create_array_envelope
static ArrayType * create_array_envelope(int ndims, int *dimv, int *lbv, int nbytes, Oid elmtype, int dataoffset)
Definition: arrayfuncs.c:5677
array_replace
Datum array_replace(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:6247
ArrayGetOffset
int ArrayGetOffset(int n, const int *dim, const int *lb, const int *indx)
Definition: arrayutils.c:31
ArrayCastAndSet
static int ArrayCastAndSet(Datum src, int typlen, bool typbyval, char typalign, char *dest)
Definition: arrayfuncs.c:4456
VARSIZE
#define VARSIZE(PTR)
Definition: postgres.h:306
array_iter_next
static Datum array_iter_next(array_iter *it, bool *isnull, int i, int elmlen, bool elmbyval, char elmalign)
Definition: arrayaccess.h:81
get_element_type
Oid get_element_type(Oid typid)
Definition: lsyscache.c:2387
SRF_IS_FIRSTCALL
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:285
generate_subscripts_fctx::lower
int32 lower
Definition: arrayfuncs.c:5516
get_typlenbyvalalign
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:1924
PointerGetDatum
#define PointerGetDatum(X)
Definition: postgres.h:564
PG_GETARG_DATUM
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:224
mda_get_prod
void mda_get_prod(int n, const int *range, int *prod)
Definition: arrayutils.c:134
get_array_type
Oid get_array_type(Oid typid)
Definition: lsyscache.c:2415
pq_begintypsend
void pq_begintypsend(StringInfo buf)
Definition: pqformat.c:358
VARHDRSZ
#define VARHDRSZ
Definition: c.h:429
pstrdup
char * pstrdup(const char *in)
Definition: mcxt.c:1160
TYPECACHE_EQ_OPR_FINFO
#define TYPECACHE_EQ_OPR_FINFO
Definition: typcache.h:115
ArrayBuildState::dvalues
Datum * dvalues
Definition: array.h:171
array_bitmap_copy
void array_bitmap_copy(bits8 *destbitmap, int destoffset, const bits8 *srcbitmap, int srcoffset, int nitems)
Definition: arrayfuncs.c:4595
ArrayType::dataoffset
int32 dataoffset
Definition: array.h:80
array_slice_size
static int array_slice_size(char *arraydataptr, bits8 *arraynullsptr, int ndim, int *dim, int *lb, int *st, int *endp, int typlen, bool typbyval, char typalign)
Definition: arrayfuncs.c:4666
StringInfo
StringInfoData * StringInfo
Definition: stringinfo.h:43
Min
#define Min(x, y)
Definition: c.h:787
TYPECACHE_HASH_PROC_FINFO
#define TYPECACHE_HASH_PROC_FINFO
Definition: typcache.h:117
ArrayGetNItems
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:75
expand_array
Datum expand_array(Datum arraydatum, MemoryContext parentcontext, ArrayMetaState *metacache)
Definition: array_expanded.c:50
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
PG_RETURN_INT32
#define PG_RETURN_INT32(x)
Definition: fmgr.h:298
AARR_HASNULL
#define AARR_HASNULL(a)
Definition: array.h:311
construct_array
ArrayType * construct_array(Datum *elems, int nelems, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3277
Array_nulls
bool Array_nulls
Definition: arrayfuncs.c:39
ArrayBuildState::typbyval
bool typbyval
Definition: array.h:177
AnyArrayType::xpn
ExpandedArrayHeader xpn
Definition: array.h:161
ArrayBuildState::element_type
Oid element_type
Definition: array.h:175
errcode
int errcode(int sqlerrcode)
Definition: elog.c:573
ArrayBuildState::private_cxt
bool private_cxt
Definition: array.h:179
MemSet
#define MemSet(start, val, len)
Definition: c.h:838
format_type_be
char * format_type_be(Oid type_oid)
Definition: format_type.c:94
array_set_element
Datum array_set_element(Datum arraydatum, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:2179
array_set
ArrayType * array_set(ArrayType *array, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3051
PG_GETARG_POINTER
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:232
ExpandedArrayHeader::dvalues
Datum * dvalues
Definition: array.h:130
array_recv
Datum array_recv(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1254
array_extract_slice
static void array_extract_slice(ArrayType *newarray, int ndim, int *dim, int *lb, char *arraydataptr, bits8 *arraynullsptr, int *st, int *endp, int typlen, bool typbyval, char typalign)
Definition: arrayfuncs.c:4726
array_cmp
static int array_cmp(FunctionCallInfo fcinfo)
Definition: arrayfuncs.c:3731
PG_GETARG_BOOL
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:230
pg_strcasecmp
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
PG_RETURN_BYTEA_P
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:313
array_cardinality
Datum array_cardinality(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1776
construct_empty_array
ArrayType * construct_empty_array(Oid elmtype)
Definition: arrayfuncs.c:3395
Oid
unsigned int Oid
Definition: postgres_ext.h:31
ExpandedArrayHeader::fendptr
char * fendptr
Definition: array.h:151
TypeCacheEntry::typlen
int16 typlen
Definition: typcache.h:35
ArrayBuildStateAny::scalarstate
ArrayBuildState * scalarstate
Definition: array.h:210
TypeCacheEntry::typbyval
bool typbyval
Definition: typcache.h:36
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:519
pq_endtypsend
bytea * pq_endtypsend(StringInfo buf)
Definition: pqformat.c:378
SRF_PERCALL_SETUP
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:289
ARR_OVERHEAD_WITHNULLS
#define ARR_OVERHEAD_WITHNULLS(ndims, nitems)
Definition: array.h:293
array_out
Datum array_out(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1011
ArrayParseState
ArrayParseState
Definition: arrayfuncs.c:52
PG_GET_COLLATION
#define PG_GET_COLLATION()
Definition: fmgr.h:155
ALLOCSET_DEFAULT_MINSIZE
#define ALLOCSET_DEFAULT_MINSIZE
Definition: memutils.h:142
array_copy
static int array_copy(char *destptr, int nitems, char *srcptr, int offset, bits8 *nullbitmap, int typlen, bool typbyval, char typalign)
Definition: arrayfuncs.c:4565
PG_RETURN_UINT32
#define PG_RETURN_UINT32(x)
Definition: fmgr.h:299
int32
signed int int32
Definition: c.h:242
ReadArrayStr
static void ReadArrayStr(char *arrayStr, const char *origStr, int nitems, int ndim, int *dim, FmgrInfo *inputproc, Oid typioparam, int32 typmod, char typdelim, int typlen, bool typbyval, char typalign, Datum *values, bool *nulls, bool *hasnulls, int32 *nbytes)
Definition: arrayfuncs.c:716
array_gt
Datum array_gt(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:3701
OutputFunctionCall
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1943
initArrayResultArr
ArrayBuildStateArr * initArrayResultArr(Oid array_type, Oid element_type, MemoryContext rcontext, bool subcontext)
Definition: arrayfuncs.c:5112
EA_MAGIC
#define EA_MAGIC
Definition: array.h:97
ARR_DATA_OFFSET
#define ARR_DATA_OFFSET(a)
Definition: array.h:297
arrayoverlap
Datum arrayoverlap(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:4153
ARR_LBOUND
#define ARR_LBOUND(a)
Definition: array.h:277
ArrayBuildState::dnulls
bool * dnulls
Definition: array.h:172
array_get_slice
Datum array_get_slice(Datum arraydatum, int nSubscripts, int *upperIndx, int *lowerIndx, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:2010
ArrayMetaState::typbyval
bool typbyval
Definition: array.h:221
SRF_RETURN_NEXT
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:291
ArrayIteratorData
struct ArrayIteratorData ArrayIteratorData
TypeCacheEntry::cmp_proc_finfo
FmgrInfo cmp_proc_finfo
Definition: typcache.h:68
FunctionCallInfoData::flinfo
FmgrInfo * flinfo
Definition: fmgr.h:71
PG_GETARG_ARRAYTYPE_P
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:244
ArrayBuildStateArr::nullbitmap
bits8 * nullbitmap
Definition: array.h:190
ArrayIteratorData::slice_nulls
bool * slice_nulls
Definition: arrayfuncs.c:82
pfree
void pfree(void *pointer)
Definition: mcxt.c:993
Pointer
char * Pointer
Definition: c.h:231
array_iterate
bool array_iterate(ArrayIterator iterator, Datum *value, bool *isnull)
Definition: arrayfuncs.c:4305
ERROR
#define ERROR
Definition: elog.h:41
float8
double float8
Definition: c.h:366
FmgrInfo::fn_strict
bool fn_strict
Definition: fmgr.h:58
PG_GETARG_ANY_ARRAY
#define PG_GETARG_ANY_ARRAY(n)
Definition: array.h:255
DatumGetExpandedArray
ExpandedArrayHeader * DatumGetExpandedArray(Datum d)
Definition: array_expanded.c:354
ExpandedArrayHeader::hdr
ExpandedObjectHeader hdr
Definition: array.h:102
ArrayType::elemtype
Oid elemtype
Definition: array.h:81
width_bucket_array_variable
static int width_bucket_array_variable(Datum operand, ArrayType *thresholds, Oid collation, TypeCacheEntry *typentry)
Definition: arrayfuncs.c:6436
ArrayIteratorData::slice_values
Datum * slice_values
Definition: arrayfuncs.c:81
value
static struct @72 value
get_fn_expr_argtype
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:2313
ReceiveFunctionCall
Datum ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf, Oid typioparam, int32 typmod)
Definition: fmgr.c:1967
ARR_DIMS
#define ARR_DIMS(a)
Definition: array.h:275
APPENDCHAR
#define APPENDCHAR(ch)
APPENDSTR
#define APPENDSTR(str)
ArrayMapState::inp_extra
ArrayMetaState inp_extra
Definition: array.h:234
ArrayBuildState::typalign
char typalign
Definition: array.h:178
ARR_DATA_PTR
#define ARR_DATA_PTR(a)
Definition: array.h:303
accumArrayResultArr
ArrayBuildStateArr * accumArrayResultArr(ArrayBuildStateArr *astate, Datum dvalue, bool disnull, Oid array_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5161
array_contain_compare
static bool array_contain_compare(AnyArrayType *array1, AnyArrayType *array2, Oid collation, bool matchall, void **fn_extra)
Definition: arrayfuncs.c:4010
ArrayMetaState::typlen
int16 typlen
Definition: array.h:220
FunctionCallInvoke
#define FunctionCallInvoke(fcinfo)
Definition: fmgr.h:129
buf
static char * buf
Definition: pg_test_fsync.c:65
array_get_element_expanded
static Datum array_get_element_expanded(Datum arraydatum, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:1907
memmove
#define memmove(d, s, c)
Definition: c.h:1027
PG_GETARG_OID
#define PG_GETARG_OID(n)
Definition: fmgr.h:231
width_bucket_array_fixed
static int width_bucket_array_fixed(Datum operand, ArrayType *thresholds, Oid collation, TypeCacheEntry *typentry)
Definition: arrayfuncs.c:6383
ArrayMetaState::typdelim
char typdelim
Definition: array.h:223
array_iter_setup
static void array_iter_setup(array_iter *it, AnyArrayType *a)
Definition: arrayaccess.h:49
array_set_element_expanded
static Datum array_set_element_expanded(Datum arraydatum, int nSubscripts, int *indx, Datum dataValue, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:2461
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:868
generate_subscripts_fctx
struct generate_subscripts_fctx generate_subscripts_fctx
DatumGetBool
#define DatumGetBool(X)
Definition: postgres.h:401
array_upper
Datum array_upper(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1719
uint32
unsigned int uint32
Definition: c.h:254
SendFunctionCall
bytea * SendFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:2020
TypeCacheEntry::hash_proc_finfo
FmgrInfo hash_proc_finfo
Definition: typcache.h:69
ARR_HASNULL
#define ARR_HASNULL(a)
Definition: array.h:272
FunctionCallInfoData::argnull
bool argnull[FUNC_MAX_ARGS]
Definition: fmgr.h:78
fmgr_info_cxt
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:170
htup_details.h
PG_RETURN_ARRAYTYPE_P
#define PG_RETURN_ARRAYTYPE_P(x)
Definition: array.h:246
att_addlength_pointer
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:172
ereport
#define ereport(elevel, rest)
Definition: elog.h:132
mda_get_offset_values
void mda_get_offset_values(int n, int *dist, const int *prod, const int *span)
Definition: arrayutils.c:150
makeArrayResult
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5028
ASSGN
#define ASSGN
Definition: arrayfuncs.c:44
datumCopy
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:128
array_ref
Datum array_ref(ArrayType *array, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:3034
AllocSizeIsValid
#define AllocSizeIsValid(size)
Definition: memutils.h:42
MaxAllocSize
#define MaxAllocSize
Definition: memutils.h:40
accumArrayResultAny
ArrayBuildStateAny * accumArrayResultAny(ArrayBuildStateAny *astate, Datum dvalue, bool disnull, Oid input_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5438
DatumGetEOHP
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition: expandeddatum.c:29
ExpandedArrayHeader::fvalue
ArrayType * fvalue
Definition: array.h:149
ReadArrayBinary
static void ReadArrayBinary(StringInfo buf, int nitems, FmgrInfo *receiveproc, Oid typioparam, int32 typmod, int typlen, bool typbyval, char typalign, Datum *values, bool *nulls, bool *hasnulls, int32 *nbytes)
Definition: arrayfuncs.c:1429
construct_empty_expanded_array
ExpandedArrayHeader * construct_empty_expanded_array(Oid element_type, MemoryContext parentcontext, ArrayMetaState *metacache)
Definition: arrayfuncs.c:3412
ArrayBuildStateAny::arraystate
ArrayBuildStateArr * arraystate
Definition: array.h:211
store_att_byval
#define store_att_byval(T, newdatum, attlen)
Definition: tupmacs.h:222
bits8
uint8 bits8
Definition: c.h:261
AllocSetContextCreate
MemoryContext AllocSetContextCreate(MemoryContext parent, const char *name, Size minContextSize, Size initBlockSize, Size maxBlockSize)
Definition: aset.c:436
palloc0
void * palloc0(Size size)
Definition: mcxt.c:921
DatumGetFloat8
#define DatumGetFloat8(X)
Definition: postgres.h:665
PG_RETURN_BOOL
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:303
Datum
uintptr_t Datum
Definition: postgres.h:374
PG_RETURN_DATUM
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:297
AARR_DIMS
#define AARR_DIMS(a)
Definition: array.h:317
generate_subscripts_nodir
Datum generate_subscripts_nodir(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:5590
arraycontains
Datum arraycontains(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:4171
mda_get_range
void mda_get_range(int n, int *span, const int *st, const int *endp)
Definition: arrayutils.c:120
arraycontained
Datum arraycontained(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:4189
AARR_ELEMTYPE
#define AARR_ELEMTYPE(a)
Definition: array.h:315
array_set_isnull
static void array_set_isnull(bits8 *nullbitmap, int offset, bool isNull)
Definition: arrayfuncs.c:4427
MemoryContextAllocZero
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:785
InputFunctionCall
Datum InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1893
TypeCacheEntry::eq_opr_finfo
FmgrInfo eq_opr_finfo
Definition: typcache.h:67
lookup_type_cache
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:182
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:36
array_replace_internal
static ArrayType * array_replace_internal(ArrayType *array, Datum search, bool search_isnull, Datum replace, bool replace_isnull, bool remove, Oid collation, FunctionCallInfo fcinfo)
Definition: arrayfuncs.c:5967
FmgrInfo::fn_oid
Oid fn_oid
Definition: fmgr.h:56
array_ndims
Datum array_ndims(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1638
array_eq
Datum array_eq(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:3560
FunctionCallInfoData::arg
Datum arg[FUNC_MAX_ARGS]
Definition: fmgr.h:77
ArrayBuildStateArr::lbs
int lbs[MAXDIM]
Definition: array.h:197
array_get_element
Datum array_get_element(Datum arraydatum, int nSubscripts, int *indx, int arraytyplen, int elmlen, bool elmbyval, char elmalign, bool *isNull)
Definition: arrayfuncs.c:1806
PG_RETURN_TEXT_P
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:314
array_free_iterator
void array_free_iterator(ArrayIterator iterator)
Definition: arrayfuncs.c:4388
Max
#define Max(x, y)
Definition: c.h:781
cstring_to_text
text * cstring_to_text(const char *s)
Definition: varlena.c:140
array_le
Datum array_le(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:3707
array_lt
Datum array_lt(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:3695
PG_ARGISNULL
#define PG_ARGISNULL(n)
Definition: fmgr.h:166
NULL
#define NULL
Definition: c.h:215
generate_subscripts_fctx
Definition: arrayfuncs.c:5514
AARR_LBOUND
#define AARR_LBOUND(a)
Definition: array.h:319
Assert
#define Assert(condition)
Definition: c.h:656
array_insert_slice
static void array_insert_slice(ArrayType *destArray, ArrayType *origArray, ArrayType *srcArray, int ndim, int *dim, int *lb, int *st, int *endp, int typlen, bool typbyval, char typalign)
Definition: arrayfuncs.c:4799
array_seek
static char * array_seek(char *ptr, int offset, bits8 *nullbitmap, int nitems, int typlen, bool typbyval, char typalign)
Definition: arrayfuncs.c:4495
ArrayMetaState::typioparam
Oid typioparam
Definition: array.h:224
PG_RETURN_CSTRING
#define PG_RETURN_CSTRING(x)
Definition: fmgr.h:306
AARR_NDIM
#define AARR_NDIM(a)
Definition: array.h:309
FuncCallContext::multi_call_memory_ctx
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:109
ArrayCast
static Datum ArrayCast(char *value, bool byval, int len)
Definition: arrayfuncs.c:4445
Size
size_t Size
Definition: c.h:341
InitFunctionCallInfoData
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition: fmgr.h:112
AARR_FREE_IF_COPY
#define AARR_FREE_IF_COPY(array, n)
Definition: arrayfuncs.c:46
generate_subscripts_fctx::reverse
bool reverse
Definition: arrayfuncs.c:5518
FLOAT8OID
#define FLOAT8OID
Definition: pg_type.h:411
ArrayMapState::ret_extra
ArrayMetaState ret_extra
Definition: array.h:235
array_set_slice
Datum array_set_slice(Datum arraydatum, int nSubscripts, int *upperIndx, int *lowerIndx, Datum srcArrayDatum, bool isNull, int arraytyplen, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:2734
PG_FREE_IF_COPY
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:216
PG_NARGS
#define PG_NARGS()
Definition: fmgr.h:160
FmgrInfo::fn_extra
void * fn_extra
Definition: fmgr.h:61
width_bucket_array
Datum width_bucket_array(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:6276
array_larger
Datum array_larger(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:5496
array_get_isnull
static bool array_get_isnull(const bits8 *nullbitmap, int offset)
Definition: arrayfuncs.c:4410
ARR_NDIM
#define ARR_NDIM(a)
Definition: array.h:271
repalloc
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1022
ArrayCount
static int ArrayCount(const char *str, int *dim, char typdelim)
Definition: arrayfuncs.c:451
CopyArrayEls
void CopyArrayEls(ArrayType *array, Datum *values, bool *nulls, int nitems, int typlen, bool typbyval, char typalign, bool freedata)
Definition: arrayfuncs.c:956
VARATT_IS_EXPANDED_HEADER
#define VARATT_IS_EXPANDED_HEADER(PTR)
Definition: expandeddatum.h:128
array_dims
Datum array_dims(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1654
ArrayMetaState::typiofunc
Oid typiofunc
Definition: array.h:225
DatumGetPointer
#define DatumGetPointer(X)
Definition: postgres.h:557
array_length
Datum array_length(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1749
ArrayMetaState::typalign
char typalign
Definition: array.h:222
ArrayBuildState::mcontext
MemoryContext mcontext
Definition: array.h:170
EOHPGetRWDatum
#define EOHPGetRWDatum(eohptr)
Definition: expandeddatum.h:136
deconstruct_array
void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition: arrayfuncs.c:3446
values
static Datum values[MAXATTR]
Definition: bootstrap.c:159
accumArrayResult
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:4964
makeArrayResultAny
Datum makeArrayResultAny(ArrayBuildStateAny *astate, MemoryContext rcontext, bool release)
Definition: arrayfuncs.c:5466
mda_next_tuple
int mda_next_tuple(int n, int *curr, const int *span)
Definition: arrayutils.c:175
Int32GetDatum
#define Int32GetDatum(X)
Definition: postgres.h:487
array_smaller
Datum array_smaller(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:5505
ArrayBuildStateArr::dims
int dims[MAXDIM]
Definition: array.h:196
FuncCallContext::user_fctx
void * user_fctx
Definition: funcapi.h:90
att_addlength_datum
#define att_addlength_datum(cur_offset, attlen, attdatum)
Definition: tupmacs.h:160
pq_sendbytes
void pq_sendbytes(StringInfo buf, const char *data, int datalen)
Definition: pqformat.c:114
TypeCacheEntry::typalign
char typalign
Definition: typcache.h:37
palloc
void * palloc(Size size)
Definition: mcxt.c:892
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:795
fetch_att
#define fetch_att(T, attbyval, attlen)
Definition: tupmacs.h:71
pq_sendint
void pq_sendint(StringInfo buf, int i, int b)
Definition: pqformat.c:235
AnyArrayType::flt
ArrayType flt
Definition: array.h:160
ArrayMetaState::proc
FmgrInfo proc
Definition: array.h:226
MemoryContextAlloc
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:750
ALLOCSET_DEFAULT_INITSIZE
#define ALLOCSET_DEFAULT_INITSIZE
Definition: memutils.h:143
i
int i
Definition: preproc-comment.c:23
ArrayBuildStateArr::private_cxt
bool private_cxt
Definition: array.h:200
ArrayMetaState::element_type
Oid element_type
Definition: array.h:219
ArrayBuildState::typlen
int16 typlen
Definition: array.h:176
arg
void * arg
Definition: pg_backup_utils.c:27
PG_GETARG_CSTRING
#define PG_GETARG_CSTRING(n)
Definition: fmgr.h:233
pg_type.h
PG_DETOAST_DATUM
#define PG_DETOAST_DATUM(datum)
Definition: fmgr.h:196
varlena
Definition: c.h:423
PG_FUNCTION_ARGS
#define PG_FUNCTION_ARGS
Definition: fmgr.h:150
width_bucket_array_float8
static int width_bucket_array_float8(Datum operand, ArrayType *thresholds)
Definition: arrayfuncs.c:6339
ALLOCSET_DEFAULT_MAXSIZE
#define ALLOCSET_DEFAULT_MAXSIZE
Definition: memutils.h:144
pq_getmsgint
unsigned int pq_getmsgint(StringInfo msg, int b)
Definition: pqformat.c:447
array_fill
Datum array_fill(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:5642
TYPECACHE_CMP_PROC_FINFO
#define TYPECACHE_CMP_PROC_FINFO
Definition: typcache.h:116
array_remove
Datum array_remove(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:6225
SET_VARSIZE
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:330
elog
#define elog
Definition: elog.h:228
hash_array
Datum hash_array(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:3902
array_nelems_size
static int array_nelems_size(char *ptr, int offset, bits8 *nullbitmap, int nitems, int typlen, bool typbyval, char typalign)
Definition: arrayfuncs.c:4543
array_iter
Definition: arrayaccess.h:33
array_lower
Datum array_lower(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1692
construct_md_array
ArrayType * construct_md_array(Datum *elems, bool *nulls, int ndims, int *dims, int *lbs, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3311
array_contains_nulls
bool array_contains_nulls(ArrayType *array)
Definition: arrayfuncs.c:3513
PointerIsValid
#define PointerIsValid(pointer)
Definition: c.h:510
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition: array.h:273
ExpandedObjectHeader::eoh_context
MemoryContext eoh_context
Definition: expandeddatum.h:107
ARR_NULLBITMAP
#define ARR_NULLBITMAP(a)
Definition: array.h:281
array_in
Datum array_in(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:171
PG_RETURN_NULL
#define PG_RETURN_NULL()
Definition: fmgr.h:289
ArrayBuildStateArr::mcontext
MemoryContext mcontext
Definition: array.h:188
ArrayGetOffset0
int ArrayGetOffset0(int n, const int *tup, const int *scale)
Definition: arrayutils.c:50
generate_subscripts_fctx::upper
int32 upper
Definition: arrayfuncs.c:5517
ArrayType::ndim
int ndim
Definition: array.h:79
ArrayIteratorData::arr
ArrayType * arr
Definition: arrayfuncs.c:69
SRF_RETURN_DONE
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:309
DatumGetArrayTypeP
#define DatumGetArrayTypeP(X)
Definition: array.h:242
SRF_FIRSTCALL_INIT
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:287
get_type_io_data
void get_type_io_data(Oid typid, IOFuncSelector which_func, int16 *typlen, bool *typbyval, char *typalign, char *typdelim, Oid *typioparam, Oid *func)
Definition: lsyscache.c:1978