48 #define AARR_FREE_IF_COPY(array,n) \ 50 if (!VARATT_IS_EXPANDED_HEADER(array)) \ 51 PG_FREE_IF_COPY(array, n); \ 92 static int ArrayCount(
const char *
str,
int *dim,
char typdelim);
93 static void ReadArrayStr(
char *arrayStr,
const char *origStr,
94 int nitems,
int ndim,
int *dim,
99 bool *hasnulls,
int32 *nbytes);
104 bool *hasnulls,
int32 *nbytes);
106 int nSubscripts,
int *indx,
108 int elmlen,
bool elmbyval,
char elmalign,
111 int nSubscripts,
int *indx,
112 Datum dataValue,
bool isNull,
114 int elmlen,
bool elmbyval,
char elmalign);
129 int ndim,
int *dim,
int *lb,
133 int ndim,
int *dim,
int *lb,
134 char *arraydataptr,
bits8 *arraynullsptr,
139 int ndim,
int *dim,
int *lb,
144 Oid elmtype,
int dataoffset);
149 Datum search,
bool search_isnull,
150 Datum replace,
bool replace_isnull,
151 bool remove,
Oid collation,
205 if (my_extra == NULL)
226 typlen = my_extra->
typlen;
261 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
262 errmsg(
"number of array dimensions (%d) exceeds the maximum allowed (%d)",
265 for (q = p; isdigit((
unsigned char) *q) || (*q ==
'-') || (*q ==
'+'); q++)
269 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
270 errmsg(
"malformed array literal: \"%s\"",
string),
271 errdetail(
"\"[\" must introduce explicitly-specified array dimensions.")));
277 lBound[ndim] = atoi(p);
279 for (q = p; isdigit((
unsigned char) *q) || (*q ==
'-') || (*q ==
'+'); q++)
283 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
284 errmsg(
"malformed array literal: \"%s\"",
string),
285 errdetail(
"Missing array dimension value.")));
294 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
295 errmsg(
"malformed array literal: \"%s\"",
string),
296 errdetail(
"Missing \"%s\" after array dimensions.",
302 if (ub < lBound[ndim])
304 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
305 errmsg(
"upper bound cannot be less than lower bound")));
307 dim[ndim] = ub - lBound[ndim] + 1;
316 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
317 errmsg(
"malformed array literal: \"%s\"",
string),
318 errdetail(
"Array value must start with \"{\" or dimension information.")));
320 for (i = 0; i < ndim; i++)
331 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
332 errmsg(
"malformed array literal: \"%s\"",
string),
333 errdetail(
"Missing \"%s\" after array dimensions.",
345 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
346 errmsg(
"malformed array literal: \"%s\"",
string),
347 errdetail(
"Array contents must start with \"{\".")));
348 ndim_braces =
ArrayCount(p, dim_braces, typdelim);
349 if (ndim_braces != ndim)
351 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
352 errmsg(
"malformed array literal: \"%s\"",
string),
353 errdetail(
"Specified array dimensions do not match array contents.")));
354 for (i = 0; i < ndim; ++
i)
356 if (dim[i] != dim_braces[i])
358 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
359 errmsg(
"malformed array literal: \"%s\"",
string),
360 errdetail(
"Specified array dimensions do not match array contents.")));
365 printf(
"array_in- ndim %d (", ndim);
366 for (i = 0; i < ndim; i++)
370 printf(
") for %s\n",
string);
380 nullsPtr = (
bool *)
palloc(nitems *
sizeof(
bool));
383 &my_extra->
proc, typioparam, typmod,
385 typlen, typbyval, typalign,
391 nbytes += dataoffset;
409 memcpy(
ARR_DIMS(retval), dim, ndim *
sizeof(
int));
410 memcpy(
ARR_LBOUND(retval), lBound, ndim *
sizeof(
int));
413 dataPtr, nullsPtr, nitems,
414 typlen, typbyval, typalign,
461 bool in_quotes =
false;
462 bool eoArray =
false;
463 bool empty_array =
true;
469 temp[
i] = dim[
i] = nelems_last[
i] = 0;
476 bool itemdone =
false;
489 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
490 errmsg(
"malformed array literal: \"%s\"", str),
505 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
506 errmsg(
"malformed array literal: \"%s\"", str),
507 errdetail(
"Unexpected \"%c\" character.",
516 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
517 errmsg(
"malformed array literal: \"%s\"", str),
531 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
532 errmsg(
"malformed array literal: \"%s\"", str),
533 errdetail(
"Unexpected array element.")));
534 in_quotes = !in_quotes;
552 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
553 errmsg(
"malformed array literal: \"%s\"", str),
554 errdetail(
"Unexpected \"%c\" character.",
557 if (nest_level >= MAXDIM)
559 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
560 errmsg(
"number of array dimensions (%d) exceeds the maximum allowed (%d)",
561 nest_level + 1, MAXDIM)));
562 temp[nest_level] = 0;
564 if (ndim < nest_level)
582 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
583 errmsg(
"malformed array literal: \"%s\"", str),
584 errdetail(
"Unexpected \"%c\" character.",
589 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
590 errmsg(
"malformed array literal: \"%s\"", str),
591 errdetail(
"Unmatched \"%c\" character.",
'}')));
594 if (nelems_last[nest_level] != 0 &&
595 nelems[nest_level] != nelems_last[nest_level])
597 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
598 errmsg(
"malformed array literal: \"%s\"", str),
599 errdetail(
"Multidimensional arrays must have " 600 "sub-arrays with matching " 602 nelems_last[nest_level] = nelems[nest_level];
603 nelems[nest_level] = 1;
605 eoArray = itemdone =
true;
612 temp[nest_level - 1]++;
619 if (*ptr == typdelim)
631 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
632 errmsg(
"malformed array literal: \"%s\"", str),
633 errdetail(
"Unexpected \"%c\" character.",
640 nelems[nest_level - 1]++;
654 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
655 errmsg(
"malformed array literal: \"%s\"", str),
656 errdetail(
"Unexpected array element.")));
674 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
675 errmsg(
"malformed array literal: \"%s\"", str),
676 errdetail(
"Junk after closing right brace.")));
683 for (
i = 0;
i < ndim; ++
i)
738 bool in_quotes =
false;
739 bool eoArray =
false;
746 MemSet(indx, 0,
sizeof(indx));
749 memset(nulls,
true, nitems *
sizeof(
bool));
769 bool itemdone =
false;
770 bool leadingspace =
true;
771 bool hasquoting =
false;
777 itemstart = dstptr = dstendptr = srcptr;
786 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
787 errmsg(
"malformed array literal: \"%s\"",
795 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
796 errmsg(
"malformed array literal: \"%s\"",
798 *dstptr++ = *srcptr++;
800 leadingspace =
false;
805 in_quotes = !in_quotes;
807 leadingspace =
false;
823 if (nest_level >= ndim)
825 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
826 errmsg(
"malformed array literal: \"%s\"",
829 indx[nest_level - 1] = 0;
833 *dstptr++ = *srcptr++;
840 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
841 errmsg(
"malformed array literal: \"%s\"",
845 indx[nest_level - 1] = 0;
848 eoArray = itemdone =
true;
850 indx[nest_level - 1]++;
854 *dstptr++ = *srcptr++;
858 *dstptr++ = *srcptr++;
859 else if (*srcptr == typdelim)
876 *dstptr++ = *srcptr++;
880 *dstptr++ = *srcptr++;
881 leadingspace =
false;
891 if (i < 0 || i >= nitems)
893 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
894 errmsg(
"malformed array literal: \"%s\"",
918 for (i = 0; i <
nitems; i++)
932 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
933 errmsg(
"array size exceeds the maximum allowed (%d)",
976 for (i = 0; i <
nitems; i++)
978 if (nulls && nulls[i])
981 elog(
ERROR,
"null array element where not supported");
994 if (bitmask == 0x100)
1003 if (bitmap && bitmask != 1)
1025 dims_str[(
MAXDIM * 33) + 2];
1034 size_t overall_length;
1052 if (my_extra == NULL)
1073 typlen = my_extra->
typlen;
1093 for (i = 0; i < ndim; i++)
1107 values = (
char **)
palloc(nitems *
sizeof(
char *));
1108 needquotes = (
bool *)
palloc(nitems *
sizeof(
bool));
1113 for (i = 0; i <
nitems; i++)
1121 typlen, typbyval, typalign);
1126 overall_length += 4;
1134 if (values[i][0] ==
'\0')
1141 for (tmp = values[i]; *tmp !=
'\0'; tmp++)
1145 overall_length += 1;
1146 if (ch ==
'"' || ch ==
'\\')
1149 overall_length += 1;
1151 else if (ch ==
'{' || ch ==
'}' || ch == typdelim ||
1157 needquotes[
i] = needquote;
1161 overall_length += 2;
1163 overall_length += 1;
1172 for (i = j = 0, k = 1; i < ndim; i++)
1174 j += k, k *= dims[
i];
1176 overall_length += 2 * j;
1182 char *ptr = dims_str;
1184 for (i = 0; i < ndim; i++)
1186 sprintf(ptr,
"[%d:%d]", lb[i], lb[i] + dims[i] - 1);
1191 overall_length += ptr - dims_str;
1195 retval = (
char *)
palloc(overall_length);
1198 #define APPENDSTR(str) (strcpy(p, (str)), p += strlen(p)) 1199 #define APPENDCHAR(ch) (*p++ = (ch), *p = '\0') 1204 for (i = 0; i < ndim; i++)
1210 for (i = j; i < ndim - 1; i++)
1216 for (tmp = values[k]; *tmp; tmp++)
1220 if (ch ==
'"' || ch ==
'\\')
1231 for (i = ndim - 1; i >= 0; i--)
1233 if (++(indx[i]) < dims[i])
1251 Assert(overall_length == (p - retval + 1));
1297 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1298 errmsg(
"invalid number of dimensions: %d", ndim)));
1301 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1302 errmsg(
"number of array dimensions (%d) exceeds the maximum allowed (%d)",
1306 if (flags != 0 && flags != 1)
1308 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1309 errmsg(
"invalid array flags")));
1325 if (element_type != spec_element_type)
1330 (
errcode(ERRCODE_DATATYPE_MISMATCH),
1331 errmsg(
"binary data has array element type %u (%s) instead of expected %u (%s)",
1338 element_type = spec_element_type;
1341 for (i = 0; i < ndim; i++)
1352 int ub = lBound[
i] + dim[
i] - 1;
1356 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1357 errmsg(
"integer out of range")));
1370 if (my_extra == NULL)
1387 (
errcode(ERRCODE_UNDEFINED_FUNCTION),
1388 errmsg(
"no binary input function available for type %s",
1401 typlen = my_extra->
typlen;
1407 nullsPtr = (
bool *)
palloc(nitems *
sizeof(
bool));
1409 &my_extra->
proc, typioparam, typmod,
1410 typlen, typbyval, typalign,
1412 &hasnulls, &nbytes);
1416 nbytes += dataoffset;
1425 retval->
ndim = ndim;
1428 memcpy(
ARR_DIMS(retval), dim, ndim *
sizeof(
int));
1429 memcpy(
ARR_LBOUND(retval), lBound, ndim *
sizeof(
int));
1432 dataPtr, nullsPtr, nitems,
1433 typlen, typbyval, typalign,
1481 for (i = 0; i <
nitems; i++)
1489 if (itemlen < -1 || itemlen > (buf->
len - buf->
cursor))
1491 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1492 errmsg(
"insufficient data left in message")));
1498 typioparam, typmod);
1510 elem_buf.
maxlen = itemlen + 1;
1511 elem_buf.
len = itemlen;
1521 typioparam, typmod);
1525 if (elem_buf.
cursor != itemlen)
1527 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1528 errmsg(
"improper binary format in array element %d",
1539 for (i = 0; i <
nitems; i++)
1553 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1554 errmsg(
"array size exceeds the maximum allowed (%d)",
1558 *hasnulls = hasnull;
1591 if (my_extra == NULL)
1608 (
errcode(ERRCODE_UNDEFINED_FUNCTION),
1609 errmsg(
"no binary output function available for type %s",
1615 typlen = my_extra->
typlen;
1630 for (i = 0; i < ndim; i++)
1639 for (i = 0; i <
nitems; i++)
1646 typlen, typbyval, typalign);
1714 sprintf(p,
"[%d:%d]", lb[i], dimv[i] + lb[i] - 1);
1739 if (reqdim <= 0 || reqdim >
AARR_NDIM(v))
1743 result = lb[reqdim - 1];
1767 if (reqdim <= 0 || reqdim >
AARR_NDIM(v))
1773 result = dimv[reqdim - 1] + lb[reqdim - 1] - 1;
1796 if (reqdim <= 0 || reqdim >
AARR_NDIM(v))
1801 result = dimv[reqdim - 1];
1859 bits8 *arraynullsptr;
1861 if (arraytyplen > 0)
1867 fixedDim[0] = arraytyplen / elmlen;
1872 arraynullsptr = NULL;
1901 if (ndim != nSubscripts || ndim <= 0 || ndim >
MAXDIM)
1906 for (i = 0; i < ndim; i++)
1908 if (indx[i] < lb[i] || indx[i] >= (dim[i] + lb[i]))
1933 retptr =
array_seek(arraydataptr, 0, arraynullsptr, offset,
1934 elmlen, elmbyval, elmalign);
1935 return ArrayCast(retptr, elmbyval, elmlen);
1943 int nSubscripts,
int *indx,
1945 int elmlen,
bool elmbyval,
char elmalign,
1961 Assert(arraytyplen == -1);
1973 if (ndim != nSubscripts || ndim <= 0 || ndim >
MAXDIM)
1978 for (i = 0; i < ndim; i++)
1980 if (indx[i] < lb[i] || indx[i] >= (dim[i] + lb[i]))
2004 if (dnulls && dnulls[offset])
2017 return dvalues[offset];
2055 bool *upperProvided,
2056 bool *lowerProvided,
2073 bits8 *arraynullsptr;
2078 if (arraytyplen > 0)
2087 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2088 errmsg(
"slices of fixed-length arrays not implemented")));
2096 fixedDim[0] = arraytyplen / elmlen;
2102 arraynullsptr = NULL;
2122 if (ndim < nSubscripts || ndim <= 0 || ndim >
MAXDIM)
2125 for (i = 0; i < nSubscripts; i++)
2127 if (!lowerProvided[i] || lowerIndx[i] < lb[i])
2128 lowerIndx[
i] = lb[
i];
2129 if (!upperProvided[i] || upperIndx[i] >= (dim[i] + lb[i]))
2130 upperIndx[
i] = dim[
i] + lb[
i] - 1;
2131 if (lowerIndx[i] > upperIndx[i])
2135 for (; i < ndim; i++)
2137 lowerIndx[
i] = lb[
i];
2138 upperIndx[
i] = dim[
i] + lb[
i] - 1;
2139 if (lowerIndx[i] > upperIndx[i])
2147 lowerIndx, upperIndx,
2148 elmlen, elmbyval, elmalign);
2157 bytes += dataoffset;
2167 newarray->
ndim = ndim;
2170 memcpy(
ARR_DIMS(newarray), span, ndim *
sizeof(
int));
2177 for (i = 0; i < ndim; i++)
2182 arraydataptr, arraynullsptr,
2183 lowerIndx, upperIndx,
2184 elmlen, elmbyval, elmalign);
2241 bits8 *oldnullbitmap;
2255 if (arraytyplen > 0)
2263 if (nSubscripts != 1)
2265 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2266 errmsg(
"wrong number of array subscripts")));
2268 if (indx[0] < 0 || indx[0] * elmlen >= arraytyplen)
2270 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2271 errmsg(
"array subscript out of range")));
2275 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
2276 errmsg(
"cannot assign null value to an element of a fixed-length array")));
2278 resultarray = (
char *)
palloc(arraytyplen);
2280 elt_ptr = (
char *) resultarray + indx[0] * elmlen;
2285 if (nSubscripts <= 0 || nSubscripts >
MAXDIM)
2287 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2288 errmsg(
"wrong number of array subscripts")));
2291 if (elmlen == -1 && !isNull)
2322 for (i = 0; i < nSubscripts; i++)
2329 nSubscripts, dim, lb,
2331 elmlen, elmbyval, elmalign));
2334 if (ndim != nSubscripts)
2336 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2337 errmsg(
"wrong number of array subscripts")));
2340 memcpy(dim,
ARR_DIMS(array), ndim *
sizeof(
int));
2341 memcpy(lb,
ARR_LBOUND(array), ndim *
sizeof(
int));
2344 addedbefore = addedafter = 0;
2351 if (indx[0] < lb[0])
2353 addedbefore = lb[0] - indx[0];
2354 dim[0] += addedbefore;
2356 if (addedbefore > 1)
2359 if (indx[0] >= (dim[0] + lb[0]))
2361 addedafter = indx[0] - (dim[0] + lb[0]) + 1;
2362 dim[0] += addedafter;
2373 for (i = 0; i < ndim; i++)
2375 if (indx[i] < lb[i] ||
2376 indx[i] >= (dim[i] + lb[i]))
2378 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2379 errmsg(
"array subscript out of range")));
2394 olddatasize =
ARR_SIZE(array) - oldoverheadlen;
2400 lenafter = olddatasize;
2402 else if (addedafter)
2405 lenbefore = olddatasize;
2413 elmlen, elmbyval, elmalign);
2422 lenafter = (int) (olddatasize - lenbefore - olditemlen);
2433 newsize = overheadlen + lenbefore + newitemlen + lenafter;
2440 newarray->
ndim = ndim;
2441 newarray->
dataoffset = newhasnulls ? overheadlen : 0;
2443 memcpy(
ARR_DIMS(newarray), dim, ndim *
sizeof(
int));
2444 memcpy(
ARR_LBOUND(newarray), lb, ndim *
sizeof(
int));
2449 memcpy((
char *) newarray + overheadlen,
2450 (
char *) array + oldoverheadlen,
2454 (
char *) newarray + overheadlen + lenbefore);
2455 memcpy((
char *) newarray + overheadlen + lenbefore + newitemlen,
2456 (
char *) array + oldoverheadlen + lenbefore + olditemlen,
2470 MemSet(newnullbitmap, 0, (newnitems + 7) / 8);
2486 if (addedafter == 0)
2488 oldnullbitmap, offset + 1,
2489 oldnitems - offset - 1);
2505 int nSubscripts,
int *indx,
2506 Datum dataValue,
bool isNull,
2508 int elmlen,
bool elmbyval,
char elmalign)
2528 Assert(arraytyplen == -1);
2540 memcpy(dim, eah->
dims, ndim *
sizeof(
int));
2541 memcpy(lb, eah->
lbound, ndim *
sizeof(
int));
2542 dimschanged =
false;
2557 nSubscripts *
sizeof(
int));
2559 nSubscripts *
sizeof(
int));
2563 for (i = 0; i < nSubscripts; i++)
2570 else if (ndim != nSubscripts)
2572 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2573 errmsg(
"wrong number of array subscripts")));
2602 newhasnulls = ((dnulls != NULL) || isNull);
2603 addedbefore = addedafter = 0;
2610 if (indx[0] < lb[0])
2612 addedbefore = lb[0] - indx[0];
2613 dim[0] += addedbefore;
2616 if (addedbefore > 1)
2619 if (indx[0] >= (dim[0] + lb[0]))
2621 addedafter = indx[0] - (dim[0] + lb[0]) + 1;
2622 dim[0] += addedafter;
2634 for (i = 0; i < ndim; i++)
2636 if (indx[i] < lb[i] ||
2637 indx[i] >= (dim[i] + lb[i]))
2639 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2640 errmsg(
"array subscript out of range")));
2651 int newlen = dim[0] + dim[0] / 8;
2653 newlen =
Max(newlen, dim[0]);
2657 eah->
dnulls = dnulls = (
bool *)
2658 repalloc(dnulls, newlen *
sizeof(
bool));
2666 if (newhasnulls && dnulls == NULL)
2667 eah->
dnulls = dnulls = (
bool *)
2685 memcpy(eah->
dims, dim, ndim *
sizeof(
int));
2686 memcpy(eah->
lbound, lb, ndim *
sizeof(
int));
2690 if (addedbefore > 0)
2692 memmove(dvalues + addedbefore, dvalues, eah->
nelems *
sizeof(
Datum));
2693 for (i = 0; i < addedbefore; i++)
2694 dvalues[i] = (
Datum) 0;
2697 memmove(dnulls + addedbefore, dnulls, eah->
nelems *
sizeof(
bool));
2698 for (i = 0; i < addedbefore; i++)
2701 eah->
nelems += addedbefore;
2707 for (i = 0; i < addedafter; i++)
2711 for (i = 0; i < addedafter; i++)
2712 dnulls[eah->
nelems + i] =
true;
2714 eah->
nelems += addedafter;
2718 if (!eah->
typbyval && (dnulls == NULL || !dnulls[offset]))
2724 dvalues[offset] = dataValue;
2726 dnulls[offset] = isNull;
2736 if (oldValue < eah->fstartptr || oldValue >= eah->
fendptr)
2790 bool *upperProvided,
2791 bool *lowerProvided,
2792 Datum srcArrayDatum,
2828 if (arraytyplen > 0)
2834 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2835 errmsg(
"updates on slices of fixed-length arrays not implemented")));
2859 &dvalues, &dnulls, &nelems);
2861 for (i = 0; i < nSubscripts; i++)
2863 if (!upperProvided[i] || !lowerProvided[i])
2865 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2866 errmsg(
"array slice subscript must provide both boundaries"),
2867 errdetail(
"When assigning to a slice of an empty array value," 2868 " slice boundaries must be fully specified.")));
2870 dim[
i] = 1 + upperIndx[
i] - lowerIndx[
i];
2871 lb[
i] = lowerIndx[
i];
2877 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2878 errmsg(
"source array too small")));
2882 elmlen, elmbyval, elmalign));
2885 if (ndim < nSubscripts || ndim <= 0 || ndim >
MAXDIM)
2887 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2888 errmsg(
"wrong number of array subscripts")));
2891 memcpy(dim,
ARR_DIMS(array), ndim *
sizeof(
int));
2892 memcpy(lb,
ARR_LBOUND(array), ndim *
sizeof(
int));
2895 addedbefore = addedafter = 0;
2902 Assert(nSubscripts == 1);
2903 if (!lowerProvided[0])
2904 lowerIndx[0] = lb[0];
2905 if (!upperProvided[0])
2906 upperIndx[0] = dim[0] + lb[0] - 1;
2907 if (lowerIndx[0] > upperIndx[0])
2909 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2910 errmsg(
"upper bound cannot be less than lower bound")));
2911 if (lowerIndx[0] < lb[0])
2913 if (upperIndx[0] < lb[0] - 1)
2915 addedbefore = lb[0] - lowerIndx[0];
2916 dim[0] += addedbefore;
2917 lb[0] = lowerIndx[0];
2919 if (upperIndx[0] >= (dim[0] + lb[0]))
2921 if (lowerIndx[0] > (dim[0] + lb[0]))
2923 addedafter = upperIndx[0] - (dim[0] + lb[0]) + 1;
2924 dim[0] += addedafter;
2933 for (i = 0; i < nSubscripts; i++)
2935 if (!lowerProvided[i])
2936 lowerIndx[
i] = lb[
i];
2937 if (!upperProvided[i])
2938 upperIndx[
i] = dim[
i] + lb[
i] - 1;
2939 if (lowerIndx[i] > upperIndx[i])
2941 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2942 errmsg(
"upper bound cannot be less than lower bound")));
2943 if (lowerIndx[i] < lb[i] ||
2944 upperIndx[i] >= (dim[i] + lb[i]))
2946 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2947 errmsg(
"array subscript out of range")));
2950 for (; i < ndim; i++)
2952 lowerIndx[
i] = lb[
i];
2953 upperIndx[
i] = dim[
i] + lb[
i] - 1;
2954 if (lowerIndx[i] > upperIndx[i])
2956 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2957 errmsg(
"upper bound cannot be less than lower bound")));
2972 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
2973 errmsg(
"source array too small")));
2985 elmlen, elmbyval, elmalign);
2987 olddatasize =
ARR_SIZE(array) - oldoverheadlen;
2997 lowerIndx, upperIndx,
2998 elmlen, elmbyval, elmalign);
2999 lenbefore = lenafter = 0;
3000 itemsbefore = itemsafter = nolditems = 0;
3009 int oldub = oldlb +
ARR_DIMS(array)[0] - 1;
3010 int slicelb =
Max(oldlb, lowerIndx[0]);
3011 int sliceub =
Min(oldub, upperIndx[0]);
3016 itemsbefore =
Min(slicelb, oldub + 1) - oldlb;
3019 elmlen, elmbyval, elmalign);
3021 if (slicelb > sliceub)
3028 nolditems = sliceub - slicelb + 1;
3030 itemsbefore, oldarraybitmap,
3032 elmlen, elmbyval, elmalign);
3035 itemsafter = oldub + 1 -
Max(sliceub + 1, oldlb);
3036 lenafter = olddatasize - lenbefore - olditemsize;
3039 newsize = overheadlen + olddatasize - olditemsize + newitemsize;
3043 newarray->
ndim = ndim;
3044 newarray->
dataoffset = newhasnulls ? overheadlen : 0;
3046 memcpy(
ARR_DIMS(newarray), dim, ndim *
sizeof(
int));
3047 memcpy(
ARR_LBOUND(newarray), lb, ndim *
sizeof(
int));
3057 lowerIndx, upperIndx,
3058 elmlen, elmbyval, elmalign);
3063 memcpy((
char *) newarray + overheadlen,
3064 (
char *) array + oldoverheadlen,
3066 memcpy((
char *) newarray + overheadlen + lenbefore,
3069 memcpy((
char *) newarray + overheadlen + lenbefore + newitemsize,
3070 (
char *) array + oldoverheadlen + lenbefore + olditemsize,
3079 MemSet(newnullbitmap, 0, (nitems + 7) / 8);
3087 oldnullbitmap, itemsbefore + nolditems,
3104 int arraytyplen,
int elmlen,
bool elmbyval,
char elmalign,
3108 arraytyplen, elmlen, elmbyval, elmalign,
3121 Datum dataValue,
bool isNull,
3122 int arraytyplen,
int elmlen,
bool elmbyval,
char elmalign)
3128 elmlen, elmbyval, elmalign));
3214 inp_typlen = inp_extra->
typlen;
3215 inp_typbyval = inp_extra->
typbyval;
3216 inp_typalign = inp_extra->
typalign;
3226 typlen = ret_extra->
typlen;
3232 nulls = (
bool *)
palloc(nitems *
sizeof(
bool));
3238 for (i = 0; i <
nitems; i++)
3243 inp_typlen, inp_typbyval, inp_typalign);
3261 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
3262 errmsg(
"array size exceeds the maximum allowed (%d)",
3271 nbytes += dataoffset;
3280 result->
ndim = ndim;
3287 values, nulls, nitems,
3288 typlen, typbyval, typalign,
3320 int elmlen,
bool elmbyval,
char elmalign)
3329 elmtype, elmlen, elmbyval, elmalign);
3358 Oid elmtype,
int elmlen,
bool elmbyval,
char elmalign)
3369 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3370 errmsg(
"invalid number of dimensions: %d", ndims)));
3373 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
3374 errmsg(
"number of array dimensions (%d) exceeds the maximum allowed (%d)",
3386 for (i = 0; i < nelems; i++)
3388 if (nulls && nulls[i])
3401 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
3402 errmsg(
"array size exceeds the maximum allowed (%d)",
3410 nbytes += dataoffset;
3419 result->
ndim = ndims;
3422 memcpy(
ARR_DIMS(result), dims, ndims *
sizeof(
int));
3423 memcpy(
ARR_LBOUND(result), lbs, ndims *
sizeof(
int));
3426 elems, nulls, nelems,
3427 elmlen, elmbyval, elmalign,
3490 int elmlen,
bool elmbyval,
char elmalign,
3491 Datum **elemsp,
bool **nullsp,
int *nelemsp)
3506 *nullsp = nulls = (
bool *)
palloc0(nelems *
sizeof(
bool));
3515 for (i = 0; i < nelems; i++)
3518 if (bitmap && (*bitmap & bitmask) == 0)
3525 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
3526 errmsg(
"null array element not allowed in this context")));
3539 if (bitmask == 0x100)
3572 if (*bitmap != 0xFF)
3582 if ((*bitmap & bitmask) == 0)
3627 (
errcode(ERRCODE_DATATYPE_MISMATCH),
3628 errmsg(
"cannot compare arrays of different element types")));
3631 if (ndims1 != ndims2 ||
3632 memcmp(dims1, dims2, ndims1 *
sizeof(
int)) != 0 ||
3633 memcmp(lbs1, lbs2, ndims1 *
sizeof(
int)) != 0)
3644 if (typentry == NULL ||
3645 typentry->
type_id != element_type)
3651 (
errcode(ERRCODE_UNDEFINED_FUNCTION),
3652 errmsg(
"could not identify an equality operator for type %s",
3654 fcinfo->flinfo->fn_extra = (
void *) typentry;
3656 typlen = typentry->
typlen;
3664 collation, NULL, NULL);
3671 for (i = 0; i <
nitems; i++)
3681 typlen, typbyval, typalign);
3683 typlen, typbyval, typalign);
3688 if (isnull1 && isnull2)
3690 if (isnull1 || isnull2)
3699 locfcinfo->args[0].value = elt1;
3700 locfcinfo->args[0].isnull =
false;
3701 locfcinfo->args[1].value = elt2;
3702 locfcinfo->args[1].isnull =
false;
3703 locfcinfo->isnull =
false;
3705 if (locfcinfo->isnull || !oprresult)
3798 (
errcode(ERRCODE_DATATYPE_MISMATCH),
3799 errmsg(
"cannot compare arrays of different element types")));
3808 if (typentry == NULL ||
3809 typentry->
type_id != element_type)
3815 (
errcode(ERRCODE_UNDEFINED_FUNCTION),
3816 errmsg(
"could not identify a comparison function for type %s",
3820 typlen = typentry->
typlen;
3828 collation, NULL, NULL);
3831 min_nitems =
Min(nitems1, nitems2);
3835 for (i = 0; i < min_nitems; i++)
3844 elt1 =
array_iter_next(&it1, &isnull1, i, typlen, typbyval, typalign);
3845 elt2 =
array_iter_next(&it2, &isnull2, i, typlen, typbyval, typalign);
3850 if (isnull1 && isnull2)
3866 locfcinfo->args[0].value = elt1;
3867 locfcinfo->args[0].isnull =
false;
3868 locfcinfo->args[1].value = elt2;
3869 locfcinfo->args[1].isnull =
false;
3873 Assert(!locfcinfo->isnull);
3900 if (nitems1 != nitems2)
3901 result = (nitems1 < nitems2) ? -1 : 1;
3902 else if (ndims1 != ndims2)
3903 result = (ndims1 < ndims2) ? -1 : 1;
3906 for (i = 0; i < ndims1; i++)
3908 if (dims1[i] != dims2[i])
3910 result = (dims1[
i] < dims2[
i]) ? -1 : 1;
3919 for (i = 0; i < ndims1; i++)
3921 if (lbound1[i] != lbound2[i])
3923 result = (lbound1[
i] < lbound2[
i]) ? -1 : 1;
3969 if (typentry == NULL ||
3970 typentry->
type_id != element_type)
3976 (
errcode(ERRCODE_UNDEFINED_FUNCTION),
3977 errmsg(
"could not identify a hash function for type %s",
3979 fcinfo->flinfo->fn_extra = (
void *) typentry;
3981 typlen = typentry->
typlen;
3995 for (i = 0; i <
nitems; i++)
4012 locfcinfo->args[0].value = elt;
4013 locfcinfo->args[0].isnull =
false;
4016 Assert(!locfcinfo->isnull);
4030 result = (result << 5) - result + elthash;
4062 if (typentry == NULL ||
4063 typentry->
type_id != element_type)
4069 (
errcode(ERRCODE_UNDEFINED_FUNCTION),
4070 errmsg(
"could not identify an extended hash function for type %s",
4072 fcinfo->flinfo->fn_extra = (
void *) typentry;
4074 typlen = typentry->
typlen;
4085 for (i = 0; i <
nitems; i++)
4101 locfcinfo->args[0].value = elt;
4102 locfcinfo->args[0].isnull =
false;
4104 locfcinfo->args[1].isnull =
false;
4107 Assert(!locfcinfo->isnull);
4110 result = (result << 5) - result + elthash;
4135 bool matchall,
void **fn_extra)
4138 bool result = matchall;
4154 (
errcode(ERRCODE_DATATYPE_MISMATCH),
4155 errmsg(
"cannot compare arrays of different element types")));
4164 if (typentry == NULL ||
4165 typentry->
type_id != element_type)
4171 (
errcode(ERRCODE_UNDEFINED_FUNCTION),
4172 errmsg(
"could not identify an equality operator for type %s",
4174 *fn_extra = (
void *) typentry;
4176 typlen = typentry->
typlen;
4195 element_type, typlen, typbyval, typalign,
4196 &values2, &nulls2, &nelems2);
4202 collation, NULL, NULL);
4208 for (i = 0; i < nelems1; i++)
4214 elt1 =
array_iter_next(&it1, &isnull1, i, typlen, typbyval, typalign);
4231 for (j = 0; j < nelems2; j++)
4233 Datum elt2 = values2[j];
4234 bool isnull2 = nulls2 ? nulls2[j] :
false;
4243 locfcinfo->args[0].value = elt1;
4244 locfcinfo->args[0].isnull =
false;
4245 locfcinfo->args[1].value = elt2;
4246 locfcinfo->args[1].isnull =
false;
4247 locfcinfo->isnull =
false;
4249 if (!locfcinfo->isnull && oprresult)
4285 &fcinfo->flinfo->fn_extra);
4303 &fcinfo->flinfo->fn_extra);
4321 &fcinfo->flinfo->fn_extra);
4358 if (slice_ndim < 0 || slice_ndim >
ARR_NDIM(arr))
4359 elog(
ERROR,
"invalid arguments to array_create_iterator");
4470 for (i = 0; i < iterator->
slice_len; i++)
4536 if (nullbitmap == NULL)
4538 if (nullbitmap[offset / 8] & (1 << (offset % 8)))
4555 nullbitmap += offset / 8;
4556 bitmask = 1 << (offset % 8);
4558 *nullbitmap &= ~bitmask;
4560 *nullbitmap |= bitmask;
4626 if (typlen > 0 && !nullbitmap)
4632 nullbitmap += offset / 8;
4633 bitmask = 1 << (offset % 8);
4635 for (i = 0; i <
nitems; i++)
4637 if (*nullbitmap & bitmask)
4643 if (bitmask == 0x100)
4652 for (i = 0; i <
nitems; i++)
4670 return array_seek(ptr, offset, nullbitmap, nitems,
4671 typlen, typbyval, typalign) - ptr;
4696 typlen, typbyval, typalign);
4697 memcpy(destptr, srcptr, numbytes);
4720 const bits8 *srcbitmap,
int srcoffset,
4731 destbitmap += destoffset / 8;
4732 destbitmask = 1 << (destoffset % 8);
4733 destbitval = *destbitmap;
4736 srcbitmap += srcoffset / 8;
4737 srcbitmask = 1 << (srcoffset % 8);
4738 srcbitval = *srcbitmap;
4739 while (nitems-- > 0)
4741 if (srcbitval & srcbitmask)
4742 destbitval |= destbitmask;
4744 destbitval &= ~destbitmask;
4746 if (destbitmask == 0x100)
4748 *destbitmap++ = destbitval;
4751 destbitval = *destbitmap;
4754 if (srcbitmask == 0x100)
4759 srcbitval = *srcbitmap;
4762 if (destbitmask != 1)
4763 *destbitmap = destbitval;
4767 while (nitems-- > 0)
4769 destbitval |= destbitmask;
4771 if (destbitmask == 0x100)
4773 *destbitmap++ = destbitval;
4776 destbitval = *destbitmap;
4779 if (destbitmask != 1)
4780 *destbitmap = destbitval;
4791 int ndim,
int *dim,
int *lb,
4809 if (typlen > 0 && !arraynullsptr)
4814 ptr =
array_seek(arraydataptr, 0, arraynullsptr, src_offset,
4815 typlen, typbyval, typalign);
4818 for (i = 0; i < ndim; i++)
4825 ptr =
array_seek(ptr, src_offset, arraynullsptr, dist[j],
4826 typlen, typbyval, typalign);
4827 src_offset += dist[j];
4855 bits8 *arraynullsptr,
4876 srcdataptr =
array_seek(arraydataptr, 0, arraynullsptr, src_offset,
4877 typlen, typbyval, typalign);
4881 for (i = 0; i < ndim; i++)
4890 srcdataptr =
array_seek(srcdataptr, src_offset, arraynullsptr,
4892 typlen, typbyval, typalign);
4893 src_offset += dist[j];
4896 srcdataptr, src_offset, arraynullsptr,
4897 typlen, typbyval, typalign);
4900 arraynullsptr, src_offset,
4957 origPtr, 0, origBitmap,
4958 typlen, typbyval, typalign);
4963 orig_offset = dest_offset;
4967 for (i = 0; i < ndim; i++)
4977 origPtr, orig_offset, origBitmap,
4978 typlen, typbyval, typalign);
4983 origBitmap, orig_offset,
4985 dest_offset += dist[j];
4986 orig_offset += dist[j];
4990 srcPtr, src_offset, srcBitmap,
4991 typlen, typbyval, typalign);
4994 srcBitmap, src_offset,
5001 origPtr =
array_seek(origPtr, orig_offset, origBitmap, 1,
5002 typlen, typbyval, typalign);
5007 array_copy(destPtr, orignitems - orig_offset,
5008 origPtr, orig_offset, origBitmap,
5009 typlen, typbyval, typalign);
5012 origBitmap, orig_offset,
5013 orignitems - orig_offset);
5061 astate->
alen = (subcontext ? 64 : 8);
5064 astate->
dnulls = (
bool *)
5086 Datum dvalue,
bool disnull,
5110 astate->
dnulls = (
bool *)
5124 if (astate->
typlen == -1)
5157 ndims = (astate->
nelems > 0) ? 1 : 0;
5158 dims[0] = astate->
nelems;
5246 (
errcode(ERRCODE_DATATYPE_MISMATCH),
5247 errmsg(
"data type %s is not an array type",
5254 "accumArrayResultArr",
5280 Datum dvalue,
bool disnull,
5301 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5302 errmsg(
"cannot accumulate null arrays")));
5322 if (astate->
ndims == 0)
5329 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5330 errmsg(
"cannot accumulate empty arrays")));
5333 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
5334 errmsg(
"number of array dimensions (%d) exceeds the maximum allowed (%d)",
5341 astate->
ndims = ndims + 1;
5342 astate->
dims[0] = 0;
5343 memcpy(&astate->
dims[1], dims, ndims *
sizeof(
int));
5345 memcpy(&astate->
lbs[1], lbs, ndims *
sizeof(
int));
5354 if (astate->
ndims != ndims + 1)
5356 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5357 errmsg(
"cannot accumulate arrays of different dimensionality")));
5358 for (i = 0; i < ndims; i++)
5360 if (astate->
dims[i + 1] != dims[i] || astate->
lbs[i + 1] != lbs[i])
5362 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5363 errmsg(
"cannot accumulate arrays of different dimensionality")));
5370 astate->
nbytes + ndatabytes);
5381 memcpy(astate->
data + astate->
nbytes, data, ndatabytes);
5382 astate->
nbytes += ndatabytes;
5401 else if (newnitems > astate->
aitems)
5413 astate->
dims[0] += 1;
5442 if (astate->
ndims == 0)
5457 nbytes += dataoffset;
5553 Datum dvalue,
bool disnull,
5563 input_type, rcontext);
5567 input_type, rcontext);
5662 if (reqdim <= 0 || reqdim >
AARR_NDIM(v))
5674 fctx->
lower = lb[reqdim - 1];
5675 fctx->
upper = dimv[reqdim - 1] + lb[reqdim - 1] - 1;
5726 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5727 errmsg(
"dimension array or low bound array cannot be null")));
5745 elog(
ERROR,
"could not determine data type of input");
5766 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5767 errmsg(
"dimension array or low bound array cannot be null")));
5784 elog(
ERROR,
"could not determine data type of input");
5792 Oid elmtype,
int dataoffset)
5798 result->
ndim = ndims;
5801 memcpy(
ARR_DIMS(result), dimv, ndims *
sizeof(
int));
5802 memcpy(
ARR_LBOUND(result), lbsv, ndims *
sizeof(
int));
5828 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5829 errmsg(
"wrong number of array subscripts"),
5830 errdetail(
"Dimension array must be one dimensional.")));
5834 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5835 errmsg(
"dimension values cannot be null")));
5842 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5843 errmsg(
"invalid number of dimensions: %d", ndims)));
5846 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
5847 errmsg(
"number of array dimensions (%d) exceeds the maximum allowed (%d)",
5854 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5855 errmsg(
"wrong number of array subscripts"),
5856 errdetail(
"Dimension array must be one dimensional.")));
5860 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
5861 errmsg(
"dimension values cannot be null")));
5865 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
5866 errmsg(
"wrong number of array subscripts"),
5867 errdetail(
"Low bound array has different size than dimensions array.")));
5875 for (i = 0; i <
MAXDIM; i++)
5892 if (my_extra == NULL)
5910 elmlen = my_extra->
typlen;
5930 totbytes = nbytes *
nitems;
5933 if (totbytes / nbytes != nitems ||
5936 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
5937 errmsg(
"array size exceeds the maximum allowed (%d)",
5950 for (i = 0; i <
nitems; i++)
5959 nbytes = dataoffset;
5962 elmtype, dataoffset);
5985 } array_unnest_fctx;
5988 array_unnest_fctx *fctx;
6014 fctx = (array_unnest_fctx *)
palloc(
sizeof(array_unnest_fctx));
6042 if (fctx->nextelem < fctx->numelems)
6044 int offset = fctx->nextelem++;
6048 fctx->elmlen, fctx->elmbyval, fctx->elmalign);
6100 Datum search,
bool search_isnull,
6101 Datum replace,
bool replace_isnull,
6102 bool remove,
Oid collation,
6124 bool changed =
false;