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