| blob | 85f860a32a1e0097cf302f8a6d2ee94a2448c980 |
1 /*-------------------------------------------------------------------------
2 *
3 * arrayfuncs.c
4 * Support functions for arrays.
5 *
6 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * $PostgreSQL$
12 *
13 *-------------------------------------------------------------------------
14 */
17 #include <ctype.h>
30 /*
31 * GUC parameter
32 */
35 /*
36 * Local definitions
37 */
41 {
42 ARRAY_NO_LEVEL,
43 ARRAY_LEVEL_STARTED,
44 ARRAY_ELEM_STARTED,
45 ARRAY_ELEM_COMPLETED,
46 ARRAY_QUOTED_ELEM_STARTED,
47 ARRAY_QUOTED_ELEM_COMPLETED,
48 ARRAY_ELEM_DELIMITED,
49 ARRAY_LEVEL_COMPLETED,
50 ARRAY_LEVEL_DELIMITED
102 FunctionCallInfo fcinfo);
105 /*
106 * array_in :
107 * converts an array from the external format in "string" to
108 * its internal format.
109 *
110 * return value :
111 * the internal representation of the input array
112 */
113 Datum
115 {
118 * element */
124 Oid typioparam;
128 nitems;
132 int32 nbytes;
133 int32 dataoffset;
140 /*
141 * We arrange to look up info about element type, including its input
142 * conversion proc, only once per series of calls, assuming the element
143 * type doesn't change underneath us.
144 */
147 {
152 }
155 {
156 /*
157 * Get info about element type, including its input conversion proc
158 */
166 }
173 /* Make a modifiable copy of the input */
176 /*
177 * If the input string starts with dimension info, read and use that.
178 * Otherwise, we require the input to be in curly-brace style, and we
179 * prescan the input to determine dimensions.
180 *
181 * Dimension info takes the form of one or more [n] or [m:n] items. The
182 * outer loop iterates once per dimension item.
183 */
187 {
191 /*
192 * Note: we currently allow whitespace between, but not within,
193 * dimension items.
194 */
196 p++;
199 p++;
213 {
214 /* [m:n] format */
223 }
224 else
225 {
226 /* [n] format */
228 }
243 ndim++;
244 }
247 {
248 /* No array dimensions, so intuit dimensions from brace structure */
256 }
257 else
258 {
262 /* If array dimensions are given, expect '=' operator */
269 p++;
271 /*
272 * intuit dimensions from brace structure -- it better match what we
273 * were given
274 */
285 {
290 }
291 }
293 #ifdef ARRAYDEBUG
296 {
298 };
300 #endif
302 /* This checks for overflow of the array dimensions */
304 /* Empty array? */
313 typdelim,
318 {
321 }
322 else
323 {
326 }
345 }
347 /*
348 * ArrayCount
349 * Determines the dimensions for an array string.
350 *
351 * Returns number of dimensions as function result. The axis lengths are
352 * returned in dim[], which must be of size MAXDIM.
353 */
354 static int
356 {
358 i;
370 {
373 }
377 {
381 {
387 {
389 /* Signal a premature end of the string */
396 /*
397 * An escape must be after a level start, after an element
398 * start, or after an element delimiter. In any case we
399 * now must be past an element start.
400 */
410 /* skip the escaped character */
412 ptr++;
413 else
420 /*
421 * A quote must be after a level start, after a quoted
422 * element start, or after an element delimiter. In any
423 * case we now must be past an element start.
424 */
434 else
439 {
440 /*
441 * A left brace can occur if no nesting has occurred
442 * yet, after a level start, or after a level
443 * delimiter.
444 */
458 nest_level++;
461 }
465 {
466 /*
467 * A right brace can occur after an element start, an
468 * element completion, a quoted element completion, or
469 * a level completion.
470 */
484 nest_level--;
491 "array expressions with matching "
497 else
498 {
499 /*
500 * We don't set itemdone here; see comments in
501 * ReadArrayStr
502 */
504 }
505 }
509 {
511 {
512 /*
513 * Delimiters can occur after an element start, an
514 * element completion, a quoted element
515 * completion, or a level completion.
516 */
526 else
530 }
532 {
533 /*
534 * Other non-space characters must be after a
535 * level start, after an element start, or after
536 * an element delimiter. In any case we now must
537 * be past an element start.
538 */
546 }
547 }
549 }
551 ptr++;
552 }
554 ptr++;
555 }
557 /* only whitespace is allowed after the closing brace */
559 {
564 }
566 /* special case for an empty array */
574 }
576 /*
577 * ReadArrayStr :
578 * parses the array string pointed to by "arrayStr" and converts the values
579 * to internal format. Unspecified elements are initialized to nulls.
580 * The array dimensions must already have been determined.
581 *
582 * Inputs:
583 * arrayStr: the string to parse.
584 * CAUTION: the contents of "arrayStr" will be modified!
585 * origStr: the unmodified input string, used only in error messages.
586 * nitems: total number of array elements, as already determined.
587 * ndim: number of array dimensions
588 * dim[]: array axis lengths
589 * inputproc: type-specific input procedure for element datatype.
590 * typioparam, typmod: auxiliary values to pass to inputproc.
591 * typdelim: the value delimiter (type-specific).
592 * typlen, typbyval, typalign: storage parameters of element datatype.
593 *
594 * Outputs:
595 * values[]: filled with converted data values.
596 * nulls[]: filled with is-null markers.
597 * *hasnulls: set TRUE iff there are any null elements.
598 * *nbytes: set to total size of data area needed (including alignment
599 * padding but not including array header overhead).
600 *
601 * Note that values[] and nulls[] are allocated by the caller, and must have
602 * nitems elements.
603 */
604 static void
611 Oid typioparam,
612 int32 typmod,
621 {
628 int32 totbytes;
635 /* Initialize is-null markers to true */
638 /*
639 * We have to remove " and \ characters to create a clean item value to
640 * pass to the datatype input routine. We overwrite each item value
641 * in-place within arrayStr to do this. srcptr is the current scan point,
642 * and dstptr is where we are copying to.
643 *
644 * We also want to suppress leading and trailing unquoted whitespace. We
645 * use the leadingspace flag to suppress leading space. Trailing space is
646 * tracked by using dstendptr to point to the last significant output
647 * character.
648 *
649 * The error checking in this routine is mostly pro-forma, since we expect
650 * that ArrayCount() already validated the string.
651 */
654 {
666 {
668 {
670 /* Signal a premature end of the string */
674 origStr)));
677 /* Skip backslash, copy next character as-is. */
678 srcptr++;
683 origStr)));
685 /* Treat the escaped character as non-whitespace */
694 else
695 {
696 /*
697 * Advance dstendptr when we exit in_quotes; this
698 * saves having to do it in all the other in_quotes
699 * cases.
700 */
702 }
704 srcptr++;
708 {
713 origStr)));
714 nest_level++;
716 srcptr++;
717 }
718 else
723 {
728 origStr)));
732 nest_level--;
735 else
737 srcptr++;
738 }
739 else
746 {
751 srcptr++;
752 }
754 {
755 /*
756 * If leading space, drop it immediately. Else, copy
757 * but don't advance dstendptr.
758 */
760 srcptr++;
761 else
763 }
764 else
765 {
769 }
771 }
772 }
781 origStr)));
785 {
786 /* it's a NULL item */
790 }
791 else
792 {
796 }
797 }
799 /*
800 * Check for nulls, compute total data space needed
801 */
805 {
808 else
809 {
810 /* let's just make sure data is not toasted */
815 /* check for overflow of total request */
821 }
822 }
825 }
828 /*
829 * Copy data into an array object from a temporary array of Datums.
830 *
831 * array: array object (with header fields already filled in)
832 * values: array of Datums to be copied
833 * nulls: array of is-null flags (can be NULL if no nulls)
834 * nitems: number of Datums to be copied
835 * typbyval, typlen, typalign: info about element datatype
836 * freedata: if TRUE and element type is pass-by-ref, pfree data values
837 * referenced by Datums after copying them.
838 *
839 * If the input data is of varlena type, the caller must have ensured that
840 * the values are not toasted. (Doing it here doesn't work since the
841 * caller has already allocated space for the array...)
842 */
843 static void
852 {
863 {
865 {
868 /* bitmap bit stays 0 */
869 }
870 else
871 {
876 }
878 {
881 {
885 }
886 }
887 }
891 }
893 /*
894 * array_out :
895 * takes the internal representation of an array and returns a string
896 * containing the array in its external format.
897 */
898 Datum
900 {
913 /*
914 * 33 per dim since we assume 15 digits per number + ':' +'[]'
915 *
916 * +2 allows for assignment operator + trailing null
917 */
923 overall_length,
924 i,
925 j,
926 k,
933 /*
934 * We arrange to look up info about element type, including its output
935 * conversion proc, only once per series of calls, assuming the element
936 * type doesn't change underneath us.
937 */
940 {
945 }
948 {
949 /*
950 * Get info about element type, including its output conversion proc
951 */
959 }
971 {
974 }
976 /*
977 * we will need to add explicit dimensions if any dimension has a lower
978 * bound other than one
979 */
981 {
983 {
986 }
987 }
989 /*
990 * Convert all values to string form, count total space needed (including
991 * any overhead such as escaping backslashes), and detect whether each
992 * item needs double quotes.
993 */
1003 {
1006 /* Get source element, checking for NULL */
1008 {
1012 }
1013 else
1014 {
1015 Datum itemvalue;
1022 /* count data plus backslashes; detect chars needing quotes */
1027 else
1031 {
1036 {
1039 }
1043 }
1044 }
1048 /* Count the pair of double quotes, if needed */
1051 /* and the comma */
1054 /* advance bitmap pointer if any */
1056 {
1059 {
1060 bitmap++;
1062 }
1063 }
1064 }
1066 /*
1067 * count total number of curly braces in output string
1068 */
1074 /* add explicit dimensions if required */
1076 {
1080 {
1083 }
1086 }
1091 #define APPENDSTR(str) (strcpy(p, (str)), p += strlen(p))
1101 do
1102 {
1107 {
1110 {
1116 }
1119 }
1120 else
1125 {
1128 {
1131 }
1132 else
1134 }
1138 #undef APPENDSTR
1139 #undef APPENDCHAR
1145 }
1147 /*
1148 * array_recv :
1149 * converts an array from the external binary format to
1150 * its internal format.
1151 *
1152 * return value :
1153 * the internal representation of the input array
1154 */
1155 Datum
1157 {
1160 * element */
1162 Oid element_type;
1166 Oid typioparam;
1168 nitems;
1172 int32 nbytes;
1173 int32 dataoffset;
1176 flags,
1181 /* Get the array header information */
1201 {
1202 /* XXX Can we allow taking the input element type in any cases? */
1206 }
1209 {
1212 }
1214 /* This checks for overflow of array dimensions */
1217 /*
1218 * We arrange to look up info about element type, including its receive
1219 * conversion proc, only once per series of calls, assuming the element
1220 * type doesn't change underneath us.
1221 */
1224 {
1229 }
1232 {
1233 /* Get info about element type, including its receive proc */
1246 }
1249 {
1250 /* Return empty array ... but not till we've validated element_type */
1252 }
1267 {
1270 }
1271 else
1272 {
1275 }
1293 }
1295 /*
1296 * ReadArrayBinary:
1297 * collect the data elements of an array being read in binary style.
1298 *
1299 * Inputs:
1300 * buf: the data buffer to read from.
1301 * nitems: total number of array elements (already read).
1302 * receiveproc: type-specific receive procedure for element datatype.
1303 * typioparam, typmod: auxiliary values to pass to receiveproc.
1304 * typlen, typbyval, typalign: storage parameters of element datatype.
1305 *
1306 * Outputs:
1307 * values[]: filled with converted data values.
1308 * nulls[]: filled with is-null markers.
1309 * *hasnulls: set TRUE iff there are any null elements.
1310 * *nbytes: set to total size of data area needed (including alignment
1311 * padding but not including array header overhead).
1312 *
1313 * Note that values[] and nulls[] are allocated by the caller, and must have
1314 * nitems elements.
1315 */
1316 static void
1320 Oid typioparam,
1321 int32 typmod,
1329 {
1332 int32 totbytes;
1335 {
1337 StringInfoData elem_buf;
1340 /* Get and check the item length */
1348 {
1349 /* -1 length means NULL */
1354 }
1356 /*
1357 * Rather than copying data around, we just set up a phony StringInfo
1358 * pointing to the correct portion of the input buffer. We assume we
1359 * can scribble on the input buffer so as to maintain the convention
1360 * that StringInfos have a trailing null.
1361 */
1372 /* Now call the element's receiveproc */
1377 /* Trouble if it didn't eat the whole buffer */
1385 }
1387 /*
1388 * Check for nulls, compute total data space needed
1389 */
1393 {
1396 else
1397 {
1398 /* let's just make sure data is not toasted */
1403 /* check for overflow of total request */
1409 }
1410 }
1413 }
1416 /*
1417 * array_send :
1418 * takes the internal representation of an array and returns a bytea
1419 * containing the array in its external binary format.
1420 */
1421 Datum
1423 {
1433 i;
1436 StringInfoData buf;
1439 /*
1440 * We arrange to look up info about element type, including its send
1441 * conversion proc, only once per series of calls, assuming the element
1442 * type doesn't change underneath us.
1443 */
1446 {
1451 }
1454 {
1455 /* Get info about element type, including its send proc */
1468 }
1479 /* Send the array header information */
1484 {
1487 }
1489 /* Send the array elements using the element's own sendproc */
1495 {
1496 /* Get source element, checking for NULL */
1498 {
1499 /* -1 length means a NULL */
1501 }
1502 else
1503 {
1504 Datum itemvalue;
1516 }
1518 /* advance bitmap pointer if any */
1520 {
1523 {
1524 bitmap++;
1526 }
1527 }
1528 }
1531 }
1533 /*
1534 * array_ndims :
1535 * returns the number of dimensions of the array pointed to by "v"
1536 */
1537 Datum
1539 {
1542 /* Sanity check: does it look like an array at all? */
1547 }
1549 /*
1550 * array_dims :
1551 * returns the dimensions of the array pointed to by "v", as a "text"
1552 */
1553 Datum
1555 {
1562 /*
1563 * 33 since we assume 15 digits per number + ':' +'[]'
1564 *
1565 * +1 for trailing null
1566 */
1569 /* Sanity check: does it look like an array at all? */
1578 {
1581 }
1584 }
1586 /*
1587 * array_lower :
1588 * returns the lower dimension, of the DIM requested, for
1589 * the array pointed to by "v", as an int4
1590 */
1591 Datum
1593 {
1599 /* Sanity check: does it look like an array at all? */
1603 /* Sanity check: was the requested dim valid */
1611 }
1613 /*
1614 * array_upper :
1615 * returns the upper dimension, of the DIM requested, for
1616 * the array pointed to by "v", as an int4
1617 */
1618 Datum
1620 {
1627 /* Sanity check: does it look like an array at all? */
1631 /* Sanity check: was the requested dim valid */
1641 }
1643 /*
1644 * array_length :
1645 * returns the length, of the dimension requested, for
1646 * the array pointed to by "v", as an int4
1647 */
1648 Datum
1650 {
1656 /* Sanity check: does it look like an array at all? */
1660 /* Sanity check: was the requested dim valid */
1669 }
1671 /*
1672 * array_ref :
1673 * This routine takes an array pointer and a subscript array and returns
1674 * the referenced item as a Datum. Note that for a pass-by-reference
1675 * datatype, the returned Datum is a pointer into the array object.
1676 *
1677 * This handles both ordinary varlena arrays and fixed-length arrays.
1678 *
1679 * Inputs:
1680 * array: the array object (mustn't be NULL)
1681 * nSubscripts: number of subscripts supplied
1682 * indx[]: the subscript values
1683 * arraytyplen: pg_type.typlen for the array type
1684 * elmlen: pg_type.typlen for the array's element type
1685 * elmbyval: pg_type.typbyval for the array's element type
1686 * elmalign: pg_type.typalign for the array's element type
1687 *
1688 * Outputs:
1689 * The return value is the element Datum.
1690 * *isNull is set to indicate whether the element is NULL.
1691 */
1692 Datum
1701 {
1703 ndim,
1706 offset,
1714 {
1715 /*
1716 * fixed-length arrays -- these are assumed to be 1-d, 0-based
1717 */
1725 }
1726 else
1727 {
1728 /* detoast input array if necessary */
1736 }
1738 /*
1739 * Return NULL for invalid subscript
1740 */
1742 {
1745 }
1747 {
1749 {
1752 }
1753 }
1755 /*
1756 * Calculate the element number
1757 */
1760 /*
1761 * Check for NULL array element
1762 */
1764 {
1767 }
1769 /*
1770 * OK, get the element
1771 */
1776 }
1778 /*
1779 * array_get_slice :
1780 * This routine takes an array and a range of indices (upperIndex and
1781 * lowerIndx), creates a new array structure for the referred elements
1782 * and returns a pointer to it.
1783 *
1784 * This handles both ordinary varlena arrays and fixed-length arrays.
1785 *
1786 * Inputs:
1787 * array: the array object (mustn't be NULL)
1788 * nSubscripts: number of subscripts supplied (must be same for upper/lower)
1789 * upperIndx[]: the upper subscript values
1790 * lowerIndx[]: the lower subscript values
1791 * arraytyplen: pg_type.typlen for the array type
1792 * elmlen: pg_type.typlen for the array's element type
1793 * elmbyval: pg_type.typbyval for the array's element type
1794 * elmalign: pg_type.typalign for the array's element type
1795 *
1796 * Outputs:
1797 * The return value is the new array Datum (it's never NULL)
1798 *
1799 * NOTE: we assume it is OK to scribble on the provided subscript arrays
1800 * lowerIndx[] and upperIndx[]. These are generally just temporaries.
1801 */
1802 ArrayType *
1811 {
1814 ndim,
1820 Oid elemtype;
1823 int32 dataoffset;
1828 {
1829 /*
1830 * fixed-length arrays -- currently, cannot slice these because parser
1831 * labels output as being of the fixed-length array type! Code below
1832 * shows how we could support it if the parser were changed to label
1833 * output as a suitable varlena array type.
1834 */
1839 /*
1840 * fixed-length arrays -- these are assumed to be 1-d, 0-based
1841 *
1842 * XXX where would we get the correct ELEMTYPE from?
1843 */
1852 }
1853 else
1854 {
1855 /* detoast input array if necessary */
1864 }
1866 /*
1867 * Check provided subscripts. A slice exceeding the current array limits
1868 * is silently truncated to the array limits. If we end up with an empty
1869 * slice, return an empty array.
1870 */
1875 {
1882 }
1883 /* fill any missing subscript positions with full array range */
1885 {
1890 }
1899 /*
1900 * Currently, we put a null bitmap in the result if the source has one;
1901 * could be smarter ...
1902 */
1904 {
1907 }
1908 else
1909 {
1912 }
1921 /*
1922 * Lower bounds of the new array are set to 1. Formerly (before 7.3) we
1923 * copied the given lowerIndx values ... but that seems confusing.
1924 */
1936 }
1938 /*
1939 * array_set :
1940 * This routine sets the value of an array element (specified by
1941 * a subscript array) to a new value specified by "dataValue".
1942 *
1943 * This handles both ordinary varlena arrays and fixed-length arrays.
1944 *
1945 * Inputs:
1946 * array: the initial array object (mustn't be NULL)
1947 * nSubscripts: number of subscripts supplied
1948 * indx[]: the subscript values
1949 * dataValue: the datum to be inserted at the given position
1950 * isNull: whether dataValue is NULL
1951 * arraytyplen: pg_type.typlen for the array type
1952 * elmlen: pg_type.typlen for the array's element type
1953 * elmbyval: pg_type.typbyval for the array's element type
1954 * elmalign: pg_type.typalign for the array's element type
1955 *
1956 * Result:
1957 * A new array is returned, just like the old except for the one
1958 * modified entry. The original array object is not changed.
1959 *
1960 * For one-dimensional arrays only, we allow the array to be extended
1961 * by assigning to a position outside the existing subscript range; any
1962 * positions between the existing elements and the new one are set to NULLs.
1963 * (XXX TODO: allow a corresponding behavior for multidimensional arrays)
1964 *
1965 * NOTE: For assignments, we throw an error for invalid subscripts etc,
1966 * rather than returning a NULL as the fetch operations do.
1967 */
1968 ArrayType *
1972 Datum dataValue,
1978 {
1981 ndim,
1984 offset;
1989 newnitems,
1990 olddatasize,
1991 newsize,
1992 olditemlen,
1993 newitemlen,
1994 overheadlen,
1995 oldoverheadlen,
1996 addedbefore,
1997 addedafter,
1998 lenbefore,
1999 lenafter;
2002 {
2003 /*
2004 * fixed-length arrays -- these are assumed to be 1-d, 0-based. We
2005 * cannot extend them, either.
2006 */
2027 }
2034 /* make sure item to be inserted is not toasted */
2038 /* detoast input array if necessary */
2043 /*
2044 * if number of dims is zero, i.e. an empty array, create an array with
2045 * nSubscripts dimensions, and set the lower bounds to the supplied
2046 * subscripts
2047 */
2049 {
2053 {
2056 }
2061 }
2068 /* copy dim/lb since we may modify them */
2075 /*
2076 * Check subscripts
2077 */
2079 {
2081 {
2087 }
2089 {
2094 }
2095 }
2096 else
2097 {
2098 /*
2099 * XXX currently we do not support extending multi-dimensional arrays
2100 * during assignment
2101 */
2103 {
2109 }
2110 }
2112 /*
2113 * Compute sizes of items and areas to copy
2114 */
2118 else
2125 {
2130 }
2132 {
2137 }
2138 else
2139 {
2146 else
2147 {
2150 }
2152 }
2156 else
2157 {
2160 }
2164 /*
2165 * OK, create the new array and fill in header/dimensions
2166 */
2175 /*
2176 * Fill in data
2177 */
2180 lenbefore);
2186 lenafter);
2188 /*
2189 * Fill in nulls bitmap if needed
2190 *
2191 * Note: it's possible we just replaced the last NULL with a non-NULL, and
2192 * could get rid of the bitmap. Seems not worth testing for though.
2193 */
2195 {
2198 /* Zero the bitmap to take care of marking inserted positions null */
2200 /* Fix the inserted value */
2203 else
2205 /* Fix the copied range(s) */
2209 oldnitems);
2210 else
2211 {
2214 offset);
2219 }
2220 }
2223 }
2225 /*
2226 * array_set_slice :
2227 * This routine sets the value of a range of array locations (specified
2228 * by upper and lower subscript values) to new values passed as
2229 * another array.
2230 *
2231 * This handles both ordinary varlena arrays and fixed-length arrays.
2232 *
2233 * Inputs:
2234 * array: the initial array object (mustn't be NULL)
2235 * nSubscripts: number of subscripts supplied (must be same for upper/lower)
2236 * upperIndx[]: the upper subscript values
2237 * lowerIndx[]: the lower subscript values
2238 * srcArray: the source for the inserted values
2239 * isNull: indicates whether srcArray is NULL
2240 * arraytyplen: pg_type.typlen for the array type
2241 * elmlen: pg_type.typlen for the array's element type
2242 * elmbyval: pg_type.typbyval for the array's element type
2243 * elmalign: pg_type.typalign for the array's element type
2244 *
2245 * Result:
2246 * A new array is returned, just like the old except for the
2247 * modified range. The original array object is not changed.
2248 *
2249 * For one-dimensional arrays only, we allow the array to be extended
2250 * by assigning to positions outside the existing subscript range; any
2251 * positions between the existing elements and the new ones are set to NULLs.
2252 * (XXX TODO: allow a corresponding behavior for multidimensional arrays)
2253 *
2254 * NOTE: we assume it is OK to scribble on the provided index arrays
2255 * lowerIndx[] and upperIndx[]. These are generally just temporaries.
2256 *
2257 * NOTE: For assignments, we throw an error for silly subscripts etc,
2258 * rather than returning a NULL or empty array as the fetch operations do.
2259 */
2260 ArrayType *
2271 {
2274 ndim,
2280 nsrcitems,
2281 olddatasize,
2282 newsize,
2283 olditemsize,
2284 newitemsize,
2285 overheadlen,
2286 oldoverheadlen,
2287 addedbefore,
2288 addedafter,
2289 lenbefore,
2290 lenafter,
2291 itemsbefore,
2292 itemsafter,
2293 nolditems;
2295 /* Currently, assignment from a NULL source array is a no-op */
2300 {
2301 /*
2302 * fixed-length arrays -- not got round to doing this...
2303 */
2307 }
2309 /* detoast arrays if necessary */
2313 /* note: we assume srcArray contains no toasted elements */
2317 /*
2318 * if number of dims is zero, i.e. an empty array, create an array with
2319 * nSubscripts dimensions, and set the upper and lower bounds to the
2320 * supplied subscripts
2321 */
2323 {
2333 {
2336 }
2338 /* complain if too few source items; we ignore extras, however */
2347 }
2354 /* copy dim/lb since we may modify them */
2361 /*
2362 * Check subscripts
2363 */
2365 {
2372 {
2378 }
2380 {
2385 }
2386 }
2387 else
2388 {
2389 /*
2390 * XXX currently we do not support extending multi-dimensional arrays
2391 * during assignment
2392 */
2394 {
2404 }
2405 /* fill any missing subscript positions with full array range */
2407 {
2414 }
2415 }
2417 /* Do this mainly to check for overflow */
2420 /*
2421 * Make sure source array has enough entries. Note we ignore the shape of
2422 * the source array and just read entries serially.
2423 */
2431 /*
2432 * Compute space occupied by new entries, space occupied by replaced
2433 * entries, and required space for new array.
2434 */
2437 else
2445 {
2446 /*
2447 * here we do not need to cope with extension of the array; it would
2448 * be a lot more complicated if we had to do so...
2449 */
2457 }
2458 else
2459 {
2460 /*
2461 * here we must allow for possibility of slice larger than orig array
2462 */
2472 itemsbefore,
2475 {
2478 }
2479 else
2480 {
2484 nolditems,
2486 }
2489 }
2502 {
2503 /*
2504 * here we do not need to cope with extension of the array; it would
2505 * be a lot more complicated if we had to do so...
2506 */
2511 }
2512 else
2513 {
2514 /* fill in data */
2517 lenbefore);
2520 newitemsize);
2523 lenafter);
2524 /* fill in nulls bitmap if needed */
2526 {
2530 /* Zero the bitmap to handle marking inserted positions null */
2534 itemsbefore);
2537 nsrcitems);
2540 itemsafter);
2541 }
2542 }
2545 }
2547 /*
2548 * array_map()
2549 *
2550 * Map an array through an arbitrary function. Return a new array with
2551 * same dimensions and each source element transformed by fn(). Each
2552 * source element is passed as the first argument to fn(); additional
2553 * arguments to be passed to fn() can be specified by the caller.
2554 * The output array can have a different element type than the input.
2555 *
2556 * Parameters are:
2557 * * fcinfo: a function-call data structure pre-constructed by the caller
2558 * to be ready to call the desired function, with everything except the
2559 * first argument position filled in. In particular, flinfo identifies
2560 * the function fn(), and if nargs > 1 then argument positions after the
2561 * first must be preset to the additional values to be passed. The
2562 * first argument position initially holds the input array value.
2563 * * inpType: OID of element type of input array. This must be the same as,
2564 * or binary-compatible with, the first argument type of fn().
2565 * * retType: OID of element type of output array. This must be the same as,
2566 * or binary-compatible with, the result type of fn().
2567 * * amstate: workspace for array_map. Must be zeroed by caller before
2568 * first call, and not touched after that.
2569 *
2570 * It is legitimate to pass a freshly-zeroed ArrayMapState on each call,
2571 * but better performance can be had if the state can be preserved across
2572 * a series of calls.
2573 *
2574 * NB: caller must assure that input array is not NULL. NULL elements in
2575 * the array are OK however.
2576 */
2577 Datum
2580 {
2585 Datum elt;
2591 int32 dataoffset;
2605 /* Get input array */
2618 /* Check for empty array */
2620 {
2621 /* Return empty array */
2623 }
2625 /*
2626 * We arrange to look up info about input and return element types only
2627 * once per series of calls, assuming the element type doesn't change
2628 * underneath us.
2629 */
2634 {
2640 }
2646 {
2652 }
2657 /* Allocate temporary arrays for new values */
2661 /* Loop over source data */
2668 {
2671 /* Get source element, checking for NULL */
2673 {
2675 }
2676 else
2677 {
2683 }
2685 /*
2686 * Apply the given function to source elt and extra args.
2687 */
2689 {
2693 {
2695 {
2698 }
2699 }
2700 }
2703 {
2706 }
2707 else
2713 else
2714 {
2715 /* Ensure data is not toasted */
2718 /* Update total result size */
2721 /* check for overflow of total request */
2727 }
2729 /* advance bitmap pointer if any */
2731 {
2734 {
2735 bitmap++;
2737 }
2738 }
2739 }
2741 /* Allocate and initialize the result array */
2743 {
2746 }
2747 else
2748 {
2751 }
2759 /*
2760 * Note: do not risk trying to pfree the results of the called function
2761 */
2771 }
2773 /*
2774 * construct_array --- simple method for constructing an array object
2775 *
2776 * elems: array of Datum items to become the array contents
2777 * (NULL element values are not supported).
2778 * nelems: number of items
2779 * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
2780 *
2781 * A palloc'd 1-D array object is constructed and returned. Note that
2782 * elem values will be copied into the object even if pass-by-ref type.
2783 *
2784 * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
2785 * from the system catalogs, given the elmtype. However, the caller is
2786 * in a better position to cache this info across multiple uses, or even
2787 * to hard-wire values if the element type is hard-wired.
2788 */
2789 ArrayType *
2791 Oid elmtype,
2793 {
2802 }
2804 /*
2805 * construct_md_array --- simple method for constructing an array object
2806 * with arbitrary dimensions and possible NULLs
2807 *
2808 * elems: array of Datum items to become the array contents
2809 * nulls: array of is-null flags (can be NULL if no nulls)
2810 * ndims: number of dimensions
2811 * dims: integer array with size of each dimension
2812 * lbs: integer array with lower bound of each dimension
2813 * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
2814 *
2815 * A palloc'd ndims-D array object is constructed and returned. Note that
2816 * elem values will be copied into the object even if pass-by-ref type.
2817 *
2818 * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
2819 * from the system catalogs, given the elmtype. However, the caller is
2820 * in a better position to cache this info across multiple uses, or even
2821 * to hard-wire values if the element type is hard-wired.
2822 */
2823 ArrayType *
2830 {
2833 int32 nbytes;
2834 int32 dataoffset;
2848 /* fast track for empty array */
2854 /* compute required space */
2858 {
2860 {
2863 }
2864 /* make sure data is not toasted */
2869 /* check for overflow of total request */
2875 }
2877 /* Allocate and initialize result array */
2879 {
2882 }
2883 else
2884 {
2887 }
2902 }
2904 /*
2905 * construct_empty_array --- make a zero-dimensional array of given type
2906 */
2907 ArrayType *
2909 {
2918 }
2920 /*
2921 * deconstruct_array --- simple method for extracting data from an array
2922 *
2923 * array: array object to examine (must not be NULL)
2924 * elmtype, elmlen, elmbyval, elmalign: info for the datatype of the items
2925 * elemsp: return value, set to point to palloc'd array of Datum values
2926 * nullsp: return value, set to point to palloc'd array of isnull markers
2927 * nelemsp: return value, set to number of extracted values
2928 *
2929 * The caller may pass nullsp == NULL if it does not support NULLs in the
2930 * array. Note that this produces a very uninformative error message,
2931 * so do it only in cases where a NULL is really not expected.
2932 *
2933 * If array elements are pass-by-ref data type, the returned Datums will
2934 * be pointers into the array object.
2935 *
2936 * NOTE: it would be cleaner to look up the elmlen/elmbval/elmalign info
2937 * from the system catalogs, given the elmtype. However, in most current
2938 * uses the type is hard-wired into the caller and so we can save a lookup
2939 * cycle by hard-wiring the type info as well.
2940 */
2941 void
2943 Oid elmtype,
2946 {
2961 else
2970 {
2971 /* Get source element, checking for NULL */
2973 {
2977 else
2981 }
2982 else
2983 {
2989 }
2991 /* advance bitmap pointer if any */
2993 {
2996 {
2997 bitmap++;
2999 }
3000 }
3001 }
3002 }
3005 /*
3006 * array_eq :
3007 * compares two arrays for equality
3008 * result :
3009 * returns true if the arrays are equal, false otherwise.
3010 *
3011 * Note: we do not use array_cmp here, since equality may be meaningful in
3012 * datatypes that don't have a total ordering (and hence no btree support).
3013 */
3014 Datum
3016 {
3036 FunctionCallInfoData locfcinfo;
3043 /* fast path if the arrays do not have the same dimensionality */
3047 else
3048 {
3049 /*
3050 * We arrange to look up the equality function only once per series of
3051 * calls, assuming the element type doesn't change underneath us. The
3052 * typcache is used so that we have no memory leakage when being used
3053 * as an index support function.
3054 */
3058 {
3060 TYPECACHE_EQ_OPR_FINFO);
3067 }
3072 /*
3073 * apply the operator to each pair of array elements.
3074 */
3078 /* Loop over source data */
3087 {
3088 Datum elt1;
3089 Datum elt2;
3094 /* Get elements, checking for NULL */
3096 {
3099 }
3100 else
3101 {
3106 }
3109 {
3112 }
3113 else
3114 {
3119 }
3121 /* advance bitmap pointers if any */
3124 {
3126 bitmap1++;
3128 bitmap2++;
3130 }
3132 /*
3133 * We consider two NULLs equal; NULL and not-NULL are unequal.
3134 */
3138 {
3141 }
3143 /*
3144 * Apply the operator to the element pair
3145 */
3153 {
3156 }
3157 }
3158 }
3160 /* Avoid leaking memory when handed toasted input. */
3165 }
3168 /*-----------------------------------------------------------------------------
3169 * array-array bool operators:
3170 * Given two arrays, iterate comparison operators
3171 * over the array. Uses logic similar to text comparison
3172 * functions, except element-by-element instead of
3173 * character-by-character.
3174 *----------------------------------------------------------------------------
3175 */
3177 Datum
3179 {
3181 }
3183 Datum
3185 {
3187 }
3189 Datum
3191 {
3193 }
3195 Datum
3197 {
3199 }
3201 Datum
3203 {
3205 }
3207 Datum
3209 {
3211 }
3213 /*
3214 * array_cmp()
3215 * Internal comparison function for arrays.
3216 *
3217 * Returns -1, 0 or 1
3218 */
3219 static int
3221 {
3243 FunctionCallInfoData locfcinfo;
3250 /*
3251 * We arrange to look up the comparison function only once per series of
3252 * calls, assuming the element type doesn't change underneath us. The
3253 * typcache is used so that we have no memory leakage when being used as
3254 * an index support function.
3255 */
3259 {
3261 TYPECACHE_CMP_PROC_FINFO);
3268 }
3273 /*
3274 * apply the operator to each pair of array elements.
3275 */
3279 /* Loop over source data */
3288 {
3289 Datum elt1;
3290 Datum elt2;
3293 int32 cmpresult;
3295 /* Get elements, checking for NULL */
3297 {
3300 }
3301 else
3302 {
3307 }
3310 {
3313 }
3314 else
3315 {
3320 }
3322 /* advance bitmap pointers if any */
3325 {
3327 bitmap1++;
3329 bitmap2++;
3331 }
3333 /*
3334 * We consider two NULLs equal; NULL > not-NULL.
3335 */
3339 {
3340 /* arg1 is greater than arg2 */
3343 }
3345 {
3346 /* arg1 is less than arg2 */
3349 }
3351 /* Compare the pair of elements */
3363 {
3364 /* arg1 is less than arg2 */
3367 }
3368 else
3369 {
3370 /* arg1 is greater than arg2 */
3373 }
3374 }
3376 /*
3377 * If arrays contain same data (up to end of shorter one), apply
3378 * additional rules to sort by dimensionality. The relative significance
3379 * of the different bits of information is historical; mainly we just care
3380 * that we don't say "equal" for arrays of different dimensionality.
3381 */
3383 {
3388 else
3389 {
3390 /* this relies on LB array immediately following DIMS array */
3392 {
3394 {
3397 }
3398 }
3399 }
3400 }
3402 /* Avoid leaking memory when handed toasted input. */
3407 }
3410 /*-----------------------------------------------------------------------------
3411 * array overlap/containment comparisons
3412 * These use the same methods of comparing array elements as array_eq.
3413 * We consider only the elements of the arrays, ignoring dimensionality.
3414 *----------------------------------------------------------------------------
3415 */
3417 /*
3418 * array_contain_compare :
3419 * compares two arrays for overlap/containment
3420 *
3421 * When matchall is true, return true if all members of array1 are in array2.
3422 * When matchall is false, return true if any members of array1 are in array2.
3423 */
3424 static bool
3427 {
3443 FunctionCallInfoData locfcinfo;
3450 /*
3451 * We arrange to look up the equality function only once per series of
3452 * calls, assuming the element type doesn't change underneath us. The
3453 * typcache is used so that we have no memory leakage when being used as
3454 * an index support function.
3455 */
3459 {
3461 TYPECACHE_EQ_OPR_FINFO);
3468 }
3473 /*
3474 * Since we probably will need to scan array2 multiple times, it's
3475 * worthwhile to use deconstruct_array on it. We scan array1 the hard way
3476 * however, since we very likely won't need to look at all of it.
3477 */
3481 /*
3482 * Apply the comparison operator to each pair of array elements.
3483 */
3487 /* Loop over source data */
3494 {
3495 Datum elt1;
3498 /* Get element, checking for NULL */
3500 {
3503 }
3504 else
3505 {
3510 }
3512 /* advance bitmap pointer if any */
3515 {
3517 bitmap1++;
3519 }
3521 /*
3522 * We assume that the comparison operator is strict, so a NULL can't
3523 * match anything. XXX this diverges from the "NULL=NULL" behavior of
3524 * array_eq, should we act like that?
3525 */
3527 {
3529 {
3532 }
3534 }
3537 {
3545 /*
3546 * Apply the operator to the element pair
3547 */
3556 }
3559 {
3560 /* found a match for elt1 */
3562 {
3565 }
3566 }
3567 else
3568 {
3569 /* no match for elt1 */
3571 {
3574 }
3575 }
3576 }
3582 }
3584 Datum
3586 {
3594 /* Avoid leaking memory when handed toasted input. */
3599 }
3601 Datum
3603 {
3611 /* Avoid leaking memory when handed toasted input. */
3616 }
3618 Datum
3620 {
3628 /* Avoid leaking memory when handed toasted input. */
3633 }
3636 /***************************************************************************/
3637 /******************| Support Routines |*****************/
3638 /***************************************************************************/
3640 /*
3641 * Check whether a specific array element is NULL
3642 *
3643 * nullbitmap: pointer to array's null bitmap (NULL if none)
3644 * offset: 0-based linear element number of array element
3645 */
3646 static bool
3648 {
3654 }
3656 /*
3657 * Set a specific array element's null-bitmap entry
3658 *
3659 * nullbitmap: pointer to array's null bitmap (mustn't be NULL)
3660 * offset: 0-based linear element number of array element
3661 * isNull: null status to set
3662 */
3663 static void
3665 {
3672 else
3674 }
3676 /*
3677 * Fetch array element at pointer, converted correctly to a Datum
3678 *
3679 * Caller must have handled case of NULL element
3680 */
3681 static Datum
3683 {
3685 }
3687 /*
3688 * Copy datum to *dest and return total space used (including align padding)
3689 *
3690 * Caller must have handled case of NULL element
3691 */
3692 static int
3698 {
3702 {
3705 else
3708 }
3709 else
3710 {
3715 }
3718 }
3720 /*
3721 * Advance ptr over nitems array elements
3722 *
3723 * ptr: starting location in array
3724 * offset: 0-based linear element number of first element (the one at *ptr)
3725 * nullbitmap: start of array's null bitmap, or NULL if none
3726 * nitems: number of array elements to advance over (>= 0)
3727 * typlen, typbyval, typalign: storage parameters of array element datatype
3728 *
3729 * It is caller's responsibility to ensure that nitems is within range
3730 */
3734 {
3738 /* easy if fixed-size elements and no NULLs */
3742 /* seems worth having separate loops for NULL and no-NULLs cases */
3744 {
3749 {
3751 {
3754 }
3757 {
3758 nullbitmap++;
3760 }
3761 }
3762 }
3763 else
3764 {
3766 {
3769 }
3770 }
3772 }
3774 /*
3775 * Compute total size of the nitems array elements starting at *ptr
3776 *
3777 * Parameters same as for array_seek
3778 */
3779 static int
3782 {
3785 }
3787 /*
3788 * Copy nitems array elements from srcptr to destptr
3789 *
3790 * destptr: starting destination location (must be enough room!)
3791 * nitems: number of array elements to copy (>= 0)
3792 * srcptr: starting location in source array
3793 * offset: 0-based linear element number of first element (the one at *srcptr)
3794 * nullbitmap: start of source array's null bitmap, or NULL if none
3795 * typlen, typbyval, typalign: storage parameters of array element datatype
3796 *
3797 * Returns number of bytes copied
3798 *
3799 * NB: this does not take care of setting up the destination's null bitmap!
3800 */
3801 static int
3805 {
3812 }
3814 /*
3815 * Copy nitems null-bitmap bits from source to destination
3816 *
3817 * destbitmap: start of destination array's null bitmap (mustn't be NULL)
3818 * destoffset: 0-based linear element number of first dest element
3819 * srcbitmap: start of source array's null bitmap, or NULL if none
3820 * srcoffset: 0-based linear element number of first source element
3821 * nitems: number of bits to copy (>= 0)
3822 *
3823 * If srcbitmap is NULL then we assume the source is all-non-NULL and
3824 * fill 1's into the destination bitmap. Note that only the specified
3825 * bits in the destination map are changed, not any before or after.
3826 *
3827 * Note: this could certainly be optimized using standard bitblt methods.
3828 * However, it's not clear that the typical Postgres array has enough elements
3829 * to make it worth worrying too much. For the moment, KISS.
3830 */
3831 void
3835 {
3837 destbitval,
3838 srcbitmask,
3839 srcbitval;
3848 {
3853 {
3856 else
3860 {
3865 }
3868 {
3869 srcbitmap++;
3873 }
3874 }
3877 }
3878 else
3879 {
3881 {
3885 {
3890 }
3891 }
3894 }
3895 }
3897 /*
3898 * Compute space needed for a slice of an array
3899 *
3900 * We assume the caller has verified that the slice coordinates are valid.
3901 */
3902 static int
3907 {
3915 j,
3916 inc;
3921 /* Pretty easy for fixed element length without nulls ... */
3925 /* Else gotta do it the hard way */
3934 do
3935 {
3937 {
3941 }
3943 {
3948 }
3949 src_offset++;
3952 }
3954 /*
3955 * Extract a slice of an array into consecutive elements in the destination
3956 * array.
3957 *
3958 * We assume the caller has verified that the slice coordinates are valid,
3959 * allocated enough storage for the result, and initialized the header
3960 * of the new array.
3961 */
3962 static void
3974 {
3979 dest_offset,
3985 j,
3986 inc;
3998 do
3999 {
4001 {
4002 /* skip unwanted elements */
4007 }
4017 src_offset++;
4018 dest_offset++;
4020 }
4022 /*
4023 * Insert a slice into an array.
4024 *
4025 * ndim/dim[]/lb[] are dimensions of the original array. A new array with
4026 * those same dimensions is to be constructed. destArray must already
4027 * have been allocated and its header initialized.
4028 *
4029 * st[]/endp[] identify the slice to be replaced. Elements within the slice
4030 * volume are taken from consecutive elements of the srcArray; elements
4031 * outside it are copied from origArray.
4032 *
4033 * We assume the caller has verified that the slice coordinates are valid.
4034 */
4035 static void
4047 {
4057 orig_offset,
4058 src_offset,
4064 j,
4065 inc;
4068 /* copy items before the slice start */
4084 do
4085 {
4086 /* Copy/advance over elements between here and next part of slice */
4088 {
4100 }
4101 /* Copy new element at this slice position */
4111 dest_offset++;
4112 src_offset++;
4113 /* Advance over old element at this slice position */
4116 orig_offset++;
4119 /* don't miss any data at the end */
4127 }
4129 /*
4130 * accumArrayResult - accumulate one (more) Datum for an array result
4131 *
4132 * astate is working state (NULL on first call)
4133 * rcontext is where to keep working state
4134 */
4135 ArrayBuildState *
4138 Oid element_type,
4139 MemoryContext rcontext)
4140 {
4141 MemoryContext arr_context,
4142 oldcontext;
4145 {
4146 /* First time through --- initialize */
4148 /* Make a temporary context to hold all the junk */
4151 ALLOCSET_DEFAULT_MINSIZE,
4152 ALLOCSET_DEFAULT_INITSIZE,
4153 ALLOCSET_DEFAULT_MAXSIZE);
4166 }
4167 else
4168 {
4171 /* enlarge dvalues[]/dnulls[] if needed */
4173 {
4179 }
4180 }
4182 /* Use datumCopy to ensure pass-by-ref stuff is copied into mcontext */
4193 }
4195 /*
4196 * makeArrayResult - produce 1-D final result of accumArrayResult
4197 *
4198 * astate is working state (not NULL)
4199 * rcontext is where to construct result
4200 */
4201 Datum
4203 MemoryContext rcontext)
4204 {
4212 }
4214 /*
4215 * makeMdArrayResult - produce multi-D final result of accumArrayResult
4216 *
4217 * beware: no check that specified dimensions match the number of values
4218 * accumulated.
4219 *
4220 * astate is working state (not NULL)
4221 * rcontext is where to construct result
4222 * release is true if okay to release working state
4223 */
4224 Datum
4229 MemoryContext rcontext,
4231 {
4233 MemoryContext oldcontext;
4235 /* Build the final array result in rcontext */
4240 ndims,
4241 dims,
4242 lbs,
4250 /* Clean up all the junk */
4255 }
4257 Datum
4259 {
4270 }
4272 Datum
4274 {
4285 }
4289 {
4290 int4 lower;
4291 int4 upper;
4295 /*
4296 * generate_subscripts(array anyarray, dim int [, reverse bool])
4297 * Returns all subscripts of the array for any dimension
4298 */
4299 Datum
4301 {
4303 MemoryContext oldcontext;
4306 /* stuff done only on the first call of the function */
4308 {
4314 /* create a function context for cross-call persistence */
4317 /* Sanity check: does it look like an array at all? */
4321 /* Sanity check: was the requested dim valid */
4325 /*
4326 * switch to memory context appropriate for multiple function calls
4327 */
4341 }
4348 {
4351 else
4353 }
4354 else
4355 /* done when there are no more elements left */
4357 }
4359 /*
4360 * generate_subscripts_nodir
4361 * Implements the 2-argument version of generate_subscripts
4362 */
4363 Datum
4365 {
4366 /* just call the other one -- it can handle both cases */
4368 }
4370 /*
4371 * array_fill_with_lower_bounds
4372 * Create and fill array with defined lower bounds.
4373 */
4374 Datum
4376 {
4380 Oid elmtype;
4381 Datum value;
4393 {
4396 }
4397 else
4398 {
4401 }
4409 }
4411 /*
4412 * array_fill
4413 * Create and fill array with default lower bounds.
4414 */
4415 Datum
4417 {
4420 Oid elmtype;
4421 Datum value;
4432 {
4435 }
4436 else
4437 {
4440 }
4448 }
4453 {
4465 }
4470 FunctionCallInfo fcinfo)
4471 {
4478 int16 elmlen;
4483 /*
4484 * Params checks
4485 */
4517 {
4542 }
4543 else
4544 {
4551 }
4553 /* fast track for empty array */
4559 /*
4560 * We arrange to look up info about element type only once per series of
4561 * calls, assuming the element type doesn't change underneath us.
4562 */
4565 {
4570 }
4573 {
4574 /* Get info about element type */
4580 }
4586 /* compute required space */
4588 {
4594 /* make sure data is not toasted */
4604 /* check for overflow of multiplication or total request */
4612 /*
4613 * This addition can't overflow, but it might cause us to go past
4614 * MaxAllocSize. We leave it to palloc to complain in that case.
4615 */
4624 }
4625 else
4626 {
4636 /* create_array_envelope already zeroed the bitmap, so we're done */
4637 }
4640 }
4643 /*
4644 * UNNEST
4645 */
4646 Datum
4648 {
4650 {
4656 int16 elmlen;
4663 MemoryContext oldcontext;
4665 /* stuff done only on the first call of the function */
4667 {
4670 /* create a function context for cross-call persistence */
4673 /*
4674 * switch to memory context appropriate for multiple function calls
4675 */
4678 /*
4679 * Get the array value and detoast if needed. We can't do this
4680 * earlier because if we have to detoast, we want the detoasted
4681 * copy to be in multi_call_memory_ctx, so it will go away when
4682 * we're done and not before. (If no detoast happens, we assume
4683 * the originally passed array will stick around till then.)
4684 */
4687 /* allocate memory for user context */
4690 /* initialize state */
4705 }
4707 /* stuff done on every call of the function */
4712 {
4714 Datum elem;
4716 /*
4717 * Check for NULL array element
4718 */
4720 {
4723 /* elemdataptr does not move */
4724 }
4725 else
4726 {
4727 /*
4728 * OK, get the element
4729 */
4735 /*
4736 * Advance elemdataptr over it
4737 */
4741 }
4744 }
4745 else
4746 {
4747 /* do when there is no more left */
4749 }
4750 }