PostgreSQL Source Code  git master
array_userfuncs.c File Reference
#include "postgres.h"
#include "catalog/pg_type.h"
#include "common/int.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/typcache.h"
Include dependency graph for array_userfuncs.c:

Go to the source code of this file.

Functions

static Datum array_position_common (FunctionCallInfo fcinfo)
 
static ExpandedArrayHeaderfetch_array_arg_replace_nulls (FunctionCallInfo fcinfo, int argno)
 
Datum array_append (PG_FUNCTION_ARGS)
 
Datum array_prepend (PG_FUNCTION_ARGS)
 
Datum array_cat (PG_FUNCTION_ARGS)
 
Datum array_agg_transfn (PG_FUNCTION_ARGS)
 
Datum array_agg_finalfn (PG_FUNCTION_ARGS)
 
Datum array_agg_array_transfn (PG_FUNCTION_ARGS)
 
Datum array_agg_array_finalfn (PG_FUNCTION_ARGS)
 
Datum array_position (PG_FUNCTION_ARGS)
 
Datum array_position_start (PG_FUNCTION_ARGS)
 
Datum array_positions (PG_FUNCTION_ARGS)
 

Function Documentation

◆ array_agg_array_finalfn()

Datum array_agg_array_finalfn ( PG_FUNCTION_ARGS  )

Definition at line 581 of file array_userfuncs.c.

References AggCheckCallContext(), Assert, CurrentMemoryContext, makeArrayResultArr(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_DATUM, and PG_RETURN_NULL.

582 {
583  Datum result;
585 
586  /* cannot be called directly because of internal-type argument */
587  Assert(AggCheckCallContext(fcinfo, NULL));
588 
589  state = PG_ARGISNULL(0) ? NULL : (ArrayBuildStateArr *) PG_GETARG_POINTER(0);
590 
591  if (state == NULL)
592  PG_RETURN_NULL(); /* returns null iff no input values */
593 
594  /*
595  * Make the result. We cannot release the ArrayBuildStateArr because
596  * sometimes aggregate final functions are re-executed. Rather, it is
597  * nodeAgg.c's responsibility to reset the aggcontext when it's safe to do
598  * so.
599  */
600  result = makeArrayResultArr(state, CurrentMemoryContext, false);
601 
602  PG_RETURN_DATUM(result);
603 }
Datum makeArrayResultArr(ArrayBuildStateArr *astate, MemoryContext rcontext, bool release)
Definition: arrayfuncs.c:5393
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:246
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
uintptr_t Datum
Definition: postgres.h:365
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:318
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
#define Assert(condition)
Definition: c.h:699
Definition: regguts.h:298
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:3492
#define PG_RETURN_NULL()
Definition: fmgr.h:310

◆ array_agg_array_transfn()

Datum array_agg_array_transfn ( PG_FUNCTION_ARGS  )

Definition at line 537 of file array_userfuncs.c.

References accumArrayResultArr(), AggCheckCallContext(), elog, ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), initArrayResultArr(), InvalidOid, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, and PG_RETURN_POINTER.

538 {
539  Oid arg1_typeid = get_fn_expr_argtype(fcinfo->flinfo, 1);
540  MemoryContext aggcontext;
542 
543  if (arg1_typeid == InvalidOid)
544  ereport(ERROR,
545  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
546  errmsg("could not determine input data type")));
547 
548  /*
549  * Note: we do not need a run-time check about whether arg1_typeid is a
550  * valid array type, because the parser would have verified that while
551  * resolving the input/result types of this polymorphic aggregate.
552  */
553 
554  if (!AggCheckCallContext(fcinfo, &aggcontext))
555  {
556  /* cannot be called directly because of internal-type argument */
557  elog(ERROR, "array_agg_array_transfn called in non-aggregate context");
558  }
559 
560 
561  if (PG_ARGISNULL(0))
562  state = initArrayResultArr(arg1_typeid, InvalidOid, aggcontext, false);
563  else
564  state = (ArrayBuildStateArr *) PG_GETARG_POINTER(0);
565 
566  state = accumArrayResultArr(state,
567  PG_GETARG_DATUM(1),
568  PG_ARGISNULL(1),
569  arg1_typeid,
570  aggcontext);
571 
572  /*
573  * The transition type for array_agg() is declared to be "internal", which
574  * is a pass-by-value type the same size as a pointer. So we can safely
575  * pass the ArrayBuildStateArr pointer through nodeAgg.c's machinations.
576  */
577  PG_RETURN_POINTER(state);
578 }
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:326
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:238
int errcode(int sqlerrcode)
Definition: elog.c:575
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:246
unsigned int Oid
Definition: postgres_ext.h:31
ArrayBuildStateArr * initArrayResultArr(Oid array_type, Oid element_type, MemoryContext rcontext, bool subcontext)
Definition: arrayfuncs.c:5190
#define ERROR
Definition: elog.h:43
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1994
ArrayBuildStateArr * accumArrayResultArr(ArrayBuildStateArr *astate, Datum dvalue, bool disnull, Oid array_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5236
#define ereport(elevel, rest)
Definition: elog.h:122
#define InvalidOid
Definition: postgres_ext.h:36
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
Definition: regguts.h:298
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:3492
int errmsg(const char *fmt,...)
Definition: elog.c:797
#define elog
Definition: elog.h:219

◆ array_agg_finalfn()

Datum array_agg_finalfn ( PG_FUNCTION_ARGS  )

Definition at line 502 of file array_userfuncs.c.

References AggCheckCallContext(), Assert, CurrentMemoryContext, makeMdArrayResult(), ArrayBuildState::nelems, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_DATUM, and PG_RETURN_NULL.

503 {
504  Datum result;
506  int dims[1];
507  int lbs[1];
508 
509  /* cannot be called directly because of internal-type argument */
510  Assert(AggCheckCallContext(fcinfo, NULL));
511 
512  state = PG_ARGISNULL(0) ? NULL : (ArrayBuildState *) PG_GETARG_POINTER(0);
513 
514  if (state == NULL)
515  PG_RETURN_NULL(); /* returns null iff no input values */
516 
517  dims[0] = state->nelems;
518  lbs[0] = 1;
519 
520  /*
521  * Make the result. We cannot release the ArrayBuildState because
522  * sometimes aggregate final functions are re-executed. Rather, it is
523  * nodeAgg.c's responsibility to reset the aggcontext when it's safe to do
524  * so.
525  */
526  result = makeMdArrayResult(state, 1, dims, lbs,
528  false);
529 
530  PG_RETURN_DATUM(result);
531 }
Datum makeMdArrayResult(ArrayBuildState *astate, int ndims, int *dims, int *lbs, MemoryContext rcontext, bool release)
Definition: arrayfuncs.c:5138
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:246
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
uintptr_t Datum
Definition: postgres.h:365
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:318
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
#define Assert(condition)
Definition: c.h:699
Definition: regguts.h:298
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:3492
#define PG_RETURN_NULL()
Definition: fmgr.h:310

◆ array_agg_transfn()

Datum array_agg_transfn ( PG_FUNCTION_ARGS  )

Definition at line 456 of file array_userfuncs.c.

References accumArrayResult(), AggCheckCallContext(), elog, ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), initArrayResult(), InvalidOid, PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, and PG_RETURN_POINTER.

457 {
458  Oid arg1_typeid = get_fn_expr_argtype(fcinfo->flinfo, 1);
459  MemoryContext aggcontext;
461  Datum elem;
462 
463  if (arg1_typeid == InvalidOid)
464  ereport(ERROR,
465  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
466  errmsg("could not determine input data type")));
467 
468  /*
469  * Note: we do not need a run-time check about whether arg1_typeid is a
470  * valid array element type, because the parser would have verified that
471  * while resolving the input/result types of this polymorphic aggregate.
472  */
473 
474  if (!AggCheckCallContext(fcinfo, &aggcontext))
475  {
476  /* cannot be called directly because of internal-type argument */
477  elog(ERROR, "array_agg_transfn called in non-aggregate context");
478  }
479 
480  if (PG_ARGISNULL(0))
481  state = initArrayResult(arg1_typeid, aggcontext, false);
482  else
483  state = (ArrayBuildState *) PG_GETARG_POINTER(0);
484 
485  elem = PG_ARGISNULL(1) ? (Datum) 0 : PG_GETARG_DATUM(1);
486 
487  state = accumArrayResult(state,
488  elem,
489  PG_ARGISNULL(1),
490  arg1_typeid,
491  aggcontext);
492 
493  /*
494  * The transition type for array_agg() is declared to be "internal", which
495  * is a pass-by-value type the same size as a pointer. So we can safely
496  * pass the ArrayBuildState pointer through nodeAgg.c's machinations.
497  */
498  PG_RETURN_POINTER(state);
499 }
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:326
ArrayBuildState * initArrayResult(Oid element_type, MemoryContext rcontext, bool subcontext)
Definition: arrayfuncs.c:5003
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:238
int errcode(int sqlerrcode)
Definition: elog.c:575
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:246
unsigned int Oid
Definition: postgres_ext.h:31
#define ERROR
Definition: elog.h:43
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1994
#define ereport(elevel, rest)
Definition: elog.h:122
uintptr_t Datum
Definition: postgres.h:365
#define InvalidOid
Definition: postgres_ext.h:36
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
Definition: regguts.h:298
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:3492
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5042
int errmsg(const char *fmt,...)
Definition: elog.c:797
#define elog
Definition: elog.h:219

◆ array_append()

Datum array_append ( PG_FUNCTION_ARGS  )

Definition at line 101 of file array_userfuncs.c.

References array_set_element(), ExpandedArrayHeader::dims, EOHPGetRWDatum, ereport, errcode(), errmsg(), ERROR, fetch_array_arg_replace_nulls(), ExpandedArrayHeader::hdr, ExpandedArrayHeader::lbound, ExpandedArrayHeader::ndims, pg_add_s32_overflow(), PG_ARGISNULL, PG_GETARG_DATUM, PG_RETURN_DATUM, ArrayMetaState::typalign, ArrayMetaState::typbyval, and ArrayMetaState::typlen.

102 {
103  ExpandedArrayHeader *eah;
104  Datum newelem;
105  bool isNull;
106  Datum result;
107  int *dimv,
108  *lb;
109  int indx;
110  ArrayMetaState *my_extra;
111 
112  eah = fetch_array_arg_replace_nulls(fcinfo, 0);
113  isNull = PG_ARGISNULL(1);
114  if (isNull)
115  newelem = (Datum) 0;
116  else
117  newelem = PG_GETARG_DATUM(1);
118 
119  if (eah->ndims == 1)
120  {
121  /* append newelem */
122  lb = eah->lbound;
123  dimv = eah->dims;
124 
125  /* index of added elem is at lb[0] + (dimv[0] - 1) + 1 */
126  if (pg_add_s32_overflow(lb[0], dimv[0], &indx))
127  ereport(ERROR,
128  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
129  errmsg("integer out of range")));
130  }
131  else if (eah->ndims == 0)
132  indx = 1;
133  else
134  ereport(ERROR,
135  (errcode(ERRCODE_DATA_EXCEPTION),
136  errmsg("argument must be empty or one-dimensional array")));
137 
138  /* Perform element insertion */
139  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
140 
141  result = array_set_element(EOHPGetRWDatum(&eah->hdr),
142  1, &indx, newelem, isNull,
143  -1, my_extra->typlen, my_extra->typbyval, my_extra->typalign);
144 
145  PG_RETURN_DATUM(result);
146 }
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:238
int errcode(int sqlerrcode)
Definition: elog.c:575
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:2187
bool typbyval
Definition: array.h:225
static ExpandedArrayHeader * fetch_array_arg_replace_nulls(FunctionCallInfo fcinfo, int argno)
#define ERROR
Definition: elog.h:43
ExpandedObjectHeader hdr
Definition: array.h:106
int16 typlen
Definition: array.h:224
#define ereport(elevel, rest)
Definition: elog.h:122
uintptr_t Datum
Definition: postgres.h:365
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:318
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
static bool pg_add_s32_overflow(int32 a, int32 b, int32 *result)
Definition: int.h:98
char typalign
Definition: array.h:226
#define EOHPGetRWDatum(eohptr)
int errmsg(const char *fmt,...)
Definition: elog.c:797

◆ array_cat()

Datum array_cat ( PG_FUNCTION_ARGS  )

Definition at line 218 of file array_userfuncs.c.

References ARR_DATA_OFFSET, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_LBOUND, ARR_NDIM, ARR_NULLBITMAP, ARR_OVERHEAD_NONULLS, ARR_OVERHEAD_WITHNULLS, ARR_SIZE, array_bitmap_copy(), ArrayGetNItems(), ArrayType::dataoffset, ArrayType::elemtype, ereport, errcode(), errdetail(), errmsg(), ERROR, format_type_be(), i, ArrayType::ndim, palloc(), palloc0(), PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_RETURN_ARRAYTYPE_P, PG_RETURN_NULL, and SET_VARSIZE.

219 {
220  ArrayType *v1,
221  *v2;
222  ArrayType *result;
223  int *dims,
224  *lbs,
225  ndims,
226  nitems,
227  ndatabytes,
228  nbytes;
229  int *dims1,
230  *lbs1,
231  ndims1,
232  nitems1,
233  ndatabytes1;
234  int *dims2,
235  *lbs2,
236  ndims2,
237  nitems2,
238  ndatabytes2;
239  int i;
240  char *dat1,
241  *dat2;
242  bits8 *bitmap1,
243  *bitmap2;
244  Oid element_type;
245  Oid element_type1;
246  Oid element_type2;
247  int32 dataoffset;
248 
249  /* Concatenating a null array is a no-op, just return the other input */
250  if (PG_ARGISNULL(0))
251  {
252  if (PG_ARGISNULL(1))
253  PG_RETURN_NULL();
254  result = PG_GETARG_ARRAYTYPE_P(1);
255  PG_RETURN_ARRAYTYPE_P(result);
256  }
257  if (PG_ARGISNULL(1))
258  {
259  result = PG_GETARG_ARRAYTYPE_P(0);
260  PG_RETURN_ARRAYTYPE_P(result);
261  }
262 
263  v1 = PG_GETARG_ARRAYTYPE_P(0);
264  v2 = PG_GETARG_ARRAYTYPE_P(1);
265 
266  element_type1 = ARR_ELEMTYPE(v1);
267  element_type2 = ARR_ELEMTYPE(v2);
268 
269  /* Check we have matching element types */
270  if (element_type1 != element_type2)
271  ereport(ERROR,
272  (errcode(ERRCODE_DATATYPE_MISMATCH),
273  errmsg("cannot concatenate incompatible arrays"),
274  errdetail("Arrays with element types %s and %s are not "
275  "compatible for concatenation.",
276  format_type_be(element_type1),
277  format_type_be(element_type2))));
278 
279  /* OK, use it */
280  element_type = element_type1;
281 
282  /*----------
283  * We must have one of the following combinations of inputs:
284  * 1) one empty array, and one non-empty array
285  * 2) both arrays empty
286  * 3) two arrays with ndims1 == ndims2
287  * 4) ndims1 == ndims2 - 1
288  * 5) ndims1 == ndims2 + 1
289  *----------
290  */
291  ndims1 = ARR_NDIM(v1);
292  ndims2 = ARR_NDIM(v2);
293 
294  /*
295  * short circuit - if one input array is empty, and the other is not, we
296  * return the non-empty one as the result
297  *
298  * if both are empty, return the first one
299  */
300  if (ndims1 == 0 && ndims2 > 0)
302 
303  if (ndims2 == 0)
305 
306  /* the rest fall under rule 3, 4, or 5 */
307  if (ndims1 != ndims2 &&
308  ndims1 != ndims2 - 1 &&
309  ndims1 != ndims2 + 1)
310  ereport(ERROR,
311  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
312  errmsg("cannot concatenate incompatible arrays"),
313  errdetail("Arrays of %d and %d dimensions are not "
314  "compatible for concatenation.",
315  ndims1, ndims2)));
316 
317  /* get argument array details */
318  lbs1 = ARR_LBOUND(v1);
319  lbs2 = ARR_LBOUND(v2);
320  dims1 = ARR_DIMS(v1);
321  dims2 = ARR_DIMS(v2);
322  dat1 = ARR_DATA_PTR(v1);
323  dat2 = ARR_DATA_PTR(v2);
324  bitmap1 = ARR_NULLBITMAP(v1);
325  bitmap2 = ARR_NULLBITMAP(v2);
326  nitems1 = ArrayGetNItems(ndims1, dims1);
327  nitems2 = ArrayGetNItems(ndims2, dims2);
328  ndatabytes1 = ARR_SIZE(v1) - ARR_DATA_OFFSET(v1);
329  ndatabytes2 = ARR_SIZE(v2) - ARR_DATA_OFFSET(v2);
330 
331  if (ndims1 == ndims2)
332  {
333  /*
334  * resulting array is made up of the elements (possibly arrays
335  * themselves) of the input argument arrays
336  */
337  ndims = ndims1;
338  dims = (int *) palloc(ndims * sizeof(int));
339  lbs = (int *) palloc(ndims * sizeof(int));
340 
341  dims[0] = dims1[0] + dims2[0];
342  lbs[0] = lbs1[0];
343 
344  for (i = 1; i < ndims; i++)
345  {
346  if (dims1[i] != dims2[i] || lbs1[i] != lbs2[i])
347  ereport(ERROR,
348  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
349  errmsg("cannot concatenate incompatible arrays"),
350  errdetail("Arrays with differing element dimensions are "
351  "not compatible for concatenation.")));
352 
353  dims[i] = dims1[i];
354  lbs[i] = lbs1[i];
355  }
356  }
357  else if (ndims1 == ndims2 - 1)
358  {
359  /*
360  * resulting array has the second argument as the outer array, with
361  * the first argument inserted at the front of the outer dimension
362  */
363  ndims = ndims2;
364  dims = (int *) palloc(ndims * sizeof(int));
365  lbs = (int *) palloc(ndims * sizeof(int));
366  memcpy(dims, dims2, ndims * sizeof(int));
367  memcpy(lbs, lbs2, ndims * sizeof(int));
368 
369  /* increment number of elements in outer array */
370  dims[0] += 1;
371 
372  /* make sure the added element matches our existing elements */
373  for (i = 0; i < ndims1; i++)
374  {
375  if (dims1[i] != dims[i + 1] || lbs1[i] != lbs[i + 1])
376  ereport(ERROR,
377  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
378  errmsg("cannot concatenate incompatible arrays"),
379  errdetail("Arrays with differing dimensions are not "
380  "compatible for concatenation.")));
381  }
382  }
383  else
384  {
385  /*
386  * (ndims1 == ndims2 + 1)
387  *
388  * resulting array has the first argument as the outer array, with the
389  * second argument appended to the end of the outer dimension
390  */
391  ndims = ndims1;
392  dims = (int *) palloc(ndims * sizeof(int));
393  lbs = (int *) palloc(ndims * sizeof(int));
394  memcpy(dims, dims1, ndims * sizeof(int));
395  memcpy(lbs, lbs1, ndims * sizeof(int));
396 
397  /* increment number of elements in outer array */
398  dims[0] += 1;
399 
400  /* make sure the added element matches our existing elements */
401  for (i = 0; i < ndims2; i++)
402  {
403  if (dims2[i] != dims[i + 1] || lbs2[i] != lbs[i + 1])
404  ereport(ERROR,
405  (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
406  errmsg("cannot concatenate incompatible arrays"),
407  errdetail("Arrays with differing dimensions are not "
408  "compatible for concatenation.")));
409  }
410  }
411 
412  /* Do this mainly for overflow checking */
413  nitems = ArrayGetNItems(ndims, dims);
414 
415  /* build the result array */
416  ndatabytes = ndatabytes1 + ndatabytes2;
417  if (ARR_HASNULL(v1) || ARR_HASNULL(v2))
418  {
419  dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
420  nbytes = ndatabytes + dataoffset;
421  }
422  else
423  {
424  dataoffset = 0; /* marker for no null bitmap */
425  nbytes = ndatabytes + ARR_OVERHEAD_NONULLS(ndims);
426  }
427  result = (ArrayType *) palloc0(nbytes);
428  SET_VARSIZE(result, nbytes);
429  result->ndim = ndims;
430  result->dataoffset = dataoffset;
431  result->elemtype = element_type;
432  memcpy(ARR_DIMS(result), dims, ndims * sizeof(int));
433  memcpy(ARR_LBOUND(result), lbs, ndims * sizeof(int));
434  /* data area is arg1 then arg2 */
435  memcpy(ARR_DATA_PTR(result), dat1, ndatabytes1);
436  memcpy(ARR_DATA_PTR(result) + ndatabytes1, dat2, ndatabytes2);
437  /* handle the null bitmap if needed */
438  if (ARR_HASNULL(result))
439  {
441  bitmap1, 0,
442  nitems1);
443  array_bitmap_copy(ARR_NULLBITMAP(result), nitems1,
444  bitmap2, 0,
445  nitems2);
446  }
447 
448  PG_RETURN_ARRAYTYPE_P(result);
449 }
#define ARR_OVERHEAD_NONULLS(ndims)
Definition: array.h:295
#define ARR_SIZE(a)
Definition: array.h:274
void array_bitmap_copy(bits8 *destbitmap, int destoffset, const bits8 *srcbitmap, int srcoffset, int nitems)
Definition: arrayfuncs.c:4676
int32 dataoffset
Definition: array.h:84
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:75
int errcode(int sqlerrcode)
Definition: elog.c:575
char * format_type_be(Oid type_oid)
Definition: format_type.c:328
unsigned int Oid
Definition: postgres_ext.h:31
#define ARR_OVERHEAD_WITHNULLS(ndims, nitems)
Definition: array.h:297
signed int int32
Definition: c.h:313
#define ARR_DATA_OFFSET(a)
Definition: array.h:301
#define ARR_LBOUND(a)
Definition: array.h:281
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:248
#define ERROR
Definition: elog.h:43
Oid elemtype
Definition: array.h:85
#define ARR_DIMS(a)
Definition: array.h:279
#define ARR_DATA_PTR(a)
Definition: array.h:307
int errdetail(const char *fmt,...)
Definition: elog.c:873
#define ARR_HASNULL(a)
Definition: array.h:276
#define PG_RETURN_ARRAYTYPE_P(x)
Definition: array.h:250
#define ereport(elevel, rest)
Definition: elog.h:122
uint8 bits8
Definition: c.h:332
void * palloc0(Size size)
Definition: mcxt.c:955
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
#define ARR_NDIM(a)
Definition: array.h:275
void * palloc(Size size)
Definition: mcxt.c:924
int errmsg(const char *fmt,...)
Definition: elog.c:797
int i
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:327
#define ARR_ELEMTYPE(a)
Definition: array.h:277
#define ARR_NULLBITMAP(a)
Definition: array.h:285
#define PG_RETURN_NULL()
Definition: fmgr.h:310
int ndim
Definition: array.h:83

◆ array_position()

Datum array_position ( PG_FUNCTION_ARGS  )

Definition at line 614 of file array_userfuncs.c.

References array_position_common().

615 {
616  return array_position_common(fcinfo);
617 }
static Datum array_position_common(FunctionCallInfo fcinfo)

◆ array_position_common()

static Datum array_position_common ( FunctionCallInfo  fcinfo)
static

Definition at line 633 of file array_userfuncs.c.

References ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_contains_nulls(), array_create_iterator(), array_free_iterator(), array_iterate(), array_iterator(), DatumGetBool, ArrayMetaState::element_type, TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoData::flinfo, fmgr_info_cxt(), FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, FmgrInfo::fn_oid, format_type_be(), FunctionCall2Coll(), get_typlenbyvalalign(), lookup_type_cache(), MemoryContextAlloc(), OidIsValid, PG_ARGISNULL, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_GETARG_INT32, PG_NARGS, PG_RETURN_INT32, PG_RETURN_NULL, ArrayMetaState::proc, ArrayMetaState::typalign, ArrayMetaState::typbyval, TYPECACHE_EQ_OPR_FINFO, ArrayMetaState::typlen, and value.

Referenced by array_position(), and array_position_start().

634 {
635  ArrayType *array;
636  Oid collation = PG_GET_COLLATION();
637  Oid element_type;
638  Datum searched_element,
639  value;
640  bool isnull;
641  int position,
642  position_min;
643  bool found = false;
644  TypeCacheEntry *typentry;
645  ArrayMetaState *my_extra;
646  bool null_search;
648 
649  if (PG_ARGISNULL(0))
650  PG_RETURN_NULL();
651 
652  array = PG_GETARG_ARRAYTYPE_P(0);
653  element_type = ARR_ELEMTYPE(array);
654 
655  /*
656  * We refuse to search for elements in multi-dimensional arrays, since we
657  * have no good way to report the element's location in the array.
658  */
659  if (ARR_NDIM(array) > 1)
660  ereport(ERROR,
661  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
662  errmsg("searching for elements in multidimensional arrays is not supported")));
663 
664  if (PG_ARGISNULL(1))
665  {
666  /* fast return when the array doesn't have nulls */
667  if (!array_contains_nulls(array))
668  PG_RETURN_NULL();
669  searched_element = (Datum) 0;
670  null_search = true;
671  }
672  else
673  {
674  searched_element = PG_GETARG_DATUM(1);
675  null_search = false;
676  }
677 
678  position = (ARR_LBOUND(array))[0] - 1;
679 
680  /* figure out where to start */
681  if (PG_NARGS() == 3)
682  {
683  if (PG_ARGISNULL(2))
684  ereport(ERROR,
685  (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
686  errmsg("initial position must not be null")));
687 
688  position_min = PG_GETARG_INT32(2);
689  }
690  else
691  position_min = (ARR_LBOUND(array))[0];
692 
693  /*
694  * We arrange to look up type info for array_create_iterator only once per
695  * series of calls, assuming the element type doesn't change underneath
696  * us.
697  */
698  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
699  if (my_extra == NULL)
700  {
701  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
702  sizeof(ArrayMetaState));
703  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
704  my_extra->element_type = ~element_type;
705  }
706 
707  if (my_extra->element_type != element_type)
708  {
709  get_typlenbyvalalign(element_type,
710  &my_extra->typlen,
711  &my_extra->typbyval,
712  &my_extra->typalign);
713 
714  typentry = lookup_type_cache(element_type, TYPECACHE_EQ_OPR_FINFO);
715 
716  if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
717  ereport(ERROR,
718  (errcode(ERRCODE_UNDEFINED_FUNCTION),
719  errmsg("could not identify an equality operator for type %s",
720  format_type_be(element_type))));
721 
722  my_extra->element_type = element_type;
723  fmgr_info_cxt(typentry->eq_opr_finfo.fn_oid, &my_extra->proc,
724  fcinfo->flinfo->fn_mcxt);
725  }
726 
727  /* Examine each array element until we find a match. */
728  array_iterator = array_create_iterator(array, 0, my_extra);
729  while (array_iterate(array_iterator, &value, &isnull))
730  {
731  position++;
732 
733  /* skip initial elements if caller requested so */
734  if (position < position_min)
735  continue;
736 
737  /*
738  * Can't look at the array element's value if it's null; but if we
739  * search for null, we have a hit and are done.
740  */
741  if (isnull || null_search)
742  {
743  if (isnull && null_search)
744  {
745  found = true;
746  break;
747  }
748  else
749  continue;
750  }
751 
752  /* not nulls, so run the operator */
753  if (DatumGetBool(FunctionCall2Coll(&my_extra->proc, collation,
754  searched_element, value)))
755  {
756  found = true;
757  break;
758  }
759  }
760 
761  array_free_iterator(array_iterator);
762 
763  /* Avoid leaking memory when handed toasted input */
764  PG_FREE_IF_COPY(array, 0);
765 
766  if (!found)
767  PG_RETURN_NULL();
768 
769  PG_RETURN_INT32(position);
770 }
ArrayIterator array_create_iterator(ArrayType *arr, int slice_ndim, ArrayMetaState *mstate)
Definition: arrayfuncs.c:4307
#define PG_GETARG_INT32(n)
Definition: fmgr.h:239
MemoryContext fn_mcxt
Definition: fmgr.h:65
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:2025
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:238
#define TYPECACHE_EQ_OPR_FINFO
Definition: typcache.h:132
#define PG_RETURN_INT32(x)
Definition: fmgr.h:319
int errcode(int sqlerrcode)
Definition: elog.c:575
char * format_type_be(Oid type_oid)
Definition: format_type.c:328
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1132
unsigned int Oid
Definition: postgres_ext.h:31
#define OidIsValid(objectId)
Definition: c.h:605
#define PG_GET_COLLATION()
Definition: fmgr.h:168
#define ARR_LBOUND(a)
Definition: array.h:281
bool typbyval
Definition: array.h:225
FmgrInfo * flinfo
Definition: fmgr.h:79
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:248
bool array_iterate(ArrayIterator iterator, Datum *value, bool *isnull)
Definition: arrayfuncs.c:4386
#define ERROR
Definition: elog.h:43
static bool array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree **found)
Definition: _ltree_op.c:37
int16 typlen
Definition: array.h:224
#define DatumGetBool(X)
Definition: postgres.h:376
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:133
#define ereport(elevel, rest)
Definition: elog.h:122
uintptr_t Datum
Definition: postgres.h:365
static struct @131 value
FmgrInfo eq_opr_finfo
Definition: typcache.h:71
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:321
Oid fn_oid
Definition: fmgr.h:59
void array_free_iterator(ArrayIterator iterator)
Definition: arrayfuncs.c:4469
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:230
#define PG_NARGS()
Definition: fmgr.h:173
void * fn_extra
Definition: fmgr.h:64
#define ARR_NDIM(a)
Definition: array.h:275
char typalign
Definition: array.h:226
int errmsg(const char *fmt,...)
Definition: elog.c:797
FmgrInfo proc
Definition: array.h:230
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:771
Oid element_type
Definition: array.h:223
bool array_contains_nulls(ArrayType *array)
Definition: arrayfuncs.c:3516
#define ARR_ELEMTYPE(a)
Definition: array.h:277
#define PG_RETURN_NULL()
Definition: fmgr.h:310

◆ array_position_start()

Datum array_position_start ( PG_FUNCTION_ARGS  )

Definition at line 620 of file array_userfuncs.c.

References array_position_common().

621 {
622  return array_position_common(fcinfo);
623 }
static Datum array_position_common(FunctionCallInfo fcinfo)

◆ array_positions()

Datum array_positions ( PG_FUNCTION_ARGS  )

Definition at line 784 of file array_userfuncs.c.

References accumArrayResult(), ARR_ELEMTYPE, ARR_LBOUND, ARR_NDIM, array_contains_nulls(), array_create_iterator(), array_free_iterator(), array_iterate(), array_iterator(), CurrentMemoryContext, DatumGetBool, ArrayMetaState::element_type, TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, fmgr_info_cxt(), FmgrInfo::fn_mcxt, FmgrInfo::fn_oid, format_type_be(), FunctionCall2Coll(), get_typlenbyvalalign(), initArrayResult(), Int32GetDatum, lookup_type_cache(), makeArrayResult(), MemoryContextAlloc(), OidIsValid, PG_ARGISNULL, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_RETURN_DATUM, PG_RETURN_NULL, ArrayMetaState::proc, ArrayMetaState::typalign, ArrayMetaState::typbyval, TYPECACHE_EQ_OPR_FINFO, ArrayMetaState::typlen, and value.

785 {
786  ArrayType *array;
787  Oid collation = PG_GET_COLLATION();
788  Oid element_type;
789  Datum searched_element,
790  value;
791  bool isnull;
792  int position;
793  TypeCacheEntry *typentry;
794  ArrayMetaState *my_extra;
795  bool null_search;
797  ArrayBuildState *astate = NULL;
798 
799  if (PG_ARGISNULL(0))
800  PG_RETURN_NULL();
801 
802  array = PG_GETARG_ARRAYTYPE_P(0);
803  element_type = ARR_ELEMTYPE(array);
804 
805  position = (ARR_LBOUND(array))[0] - 1;
806 
807  /*
808  * We refuse to search for elements in multi-dimensional arrays, since we
809  * have no good way to report the element's location in the array.
810  */
811  if (ARR_NDIM(array) > 1)
812  ereport(ERROR,
813  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
814  errmsg("searching for elements in multidimensional arrays is not supported")));
815 
816  astate = initArrayResult(INT4OID, CurrentMemoryContext, false);
817 
818  if (PG_ARGISNULL(1))
819  {
820  /* fast return when the array doesn't have nulls */
821  if (!array_contains_nulls(array))
823  searched_element = (Datum) 0;
824  null_search = true;
825  }
826  else
827  {
828  searched_element = PG_GETARG_DATUM(1);
829  null_search = false;
830  }
831 
832  /*
833  * We arrange to look up type info for array_create_iterator only once per
834  * series of calls, assuming the element type doesn't change underneath
835  * us.
836  */
837  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
838  if (my_extra == NULL)
839  {
840  fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
841  sizeof(ArrayMetaState));
842  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
843  my_extra->element_type = ~element_type;
844  }
845 
846  if (my_extra->element_type != element_type)
847  {
848  get_typlenbyvalalign(element_type,
849  &my_extra->typlen,
850  &my_extra->typbyval,
851  &my_extra->typalign);
852 
853  typentry = lookup_type_cache(element_type, TYPECACHE_EQ_OPR_FINFO);
854 
855  if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
856  ereport(ERROR,
857  (errcode(ERRCODE_UNDEFINED_FUNCTION),
858  errmsg("could not identify an equality operator for type %s",
859  format_type_be(element_type))));
860 
861  my_extra->element_type = element_type;
862  fmgr_info_cxt(typentry->eq_opr_finfo.fn_oid, &my_extra->proc,
863  fcinfo->flinfo->fn_mcxt);
864  }
865 
866  /*
867  * Accumulate each array position iff the element matches the given
868  * element.
869  */
870  array_iterator = array_create_iterator(array, 0, my_extra);
871  while (array_iterate(array_iterator, &value, &isnull))
872  {
873  position += 1;
874 
875  /*
876  * Can't look at the array element's value if it's null; but if we
877  * search for null, we have a hit.
878  */
879  if (isnull || null_search)
880  {
881  if (isnull && null_search)
882  astate =
883  accumArrayResult(astate, Int32GetDatum(position), false,
884  INT4OID, CurrentMemoryContext);
885 
886  continue;
887  }
888 
889  /* not nulls, so run the operator */
890  if (DatumGetBool(FunctionCall2Coll(&my_extra->proc, collation,
891  searched_element, value)))
892  astate =
893  accumArrayResult(astate, Int32GetDatum(position), false,
894  INT4OID, CurrentMemoryContext);
895  }
896 
897  array_free_iterator(array_iterator);
898 
899  /* Avoid leaking memory when handed toasted input */
900  PG_FREE_IF_COPY(array, 0);
901 
903 }
ArrayIterator array_create_iterator(ArrayType *arr, int slice_ndim, ArrayMetaState *mstate)
Definition: arrayfuncs.c:4307
MemoryContext fn_mcxt
Definition: fmgr.h:65
ArrayBuildState * initArrayResult(Oid element_type, MemoryContext rcontext, bool subcontext)
Definition: arrayfuncs.c:5003
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:2025
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:238
#define TYPECACHE_EQ_OPR_FINFO
Definition: typcache.h:132
int errcode(int sqlerrcode)
Definition: elog.c:575
char * format_type_be(Oid type_oid)
Definition: format_type.c:328
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1132
unsigned int Oid
Definition: postgres_ext.h:31
#define OidIsValid(objectId)
Definition: c.h:605
#define PG_GET_COLLATION()
Definition: fmgr.h:168
#define ARR_LBOUND(a)
Definition: array.h:281
bool typbyval
Definition: array.h:225
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:248
bool array_iterate(ArrayIterator iterator, Datum *value, bool *isnull)
Definition: arrayfuncs.c:4386
#define ERROR
Definition: elog.h:43
static bool array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree **found)
Definition: _ltree_op.c:37
int16 typlen
Definition: array.h:224
#define DatumGetBool(X)
Definition: postgres.h:376
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:133
#define ereport(elevel, rest)
Definition: elog.h:122
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5106
uintptr_t Datum
Definition: postgres.h:365
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:318
static struct @131 value
FmgrInfo eq_opr_finfo
Definition: typcache.h:71
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:321
Oid fn_oid
Definition: fmgr.h:59
void array_free_iterator(ArrayIterator iterator)
Definition: arrayfuncs.c:4469
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
#define PG_FREE_IF_COPY(ptr, n)
Definition: fmgr.h:230
#define ARR_NDIM(a)
Definition: array.h:275
char typalign
Definition: array.h:226
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5042
#define Int32GetDatum(X)
Definition: postgres.h:462
int errmsg(const char *fmt,...)
Definition: elog.c:797
FmgrInfo proc
Definition: array.h:230
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:771
Oid element_type
Definition: array.h:223
bool array_contains_nulls(ArrayType *array)
Definition: arrayfuncs.c:3516
#define ARR_ELEMTYPE(a)
Definition: array.h:277
#define PG_RETURN_NULL()
Definition: fmgr.h:310

◆ array_prepend()

Datum array_prepend ( PG_FUNCTION_ARGS  )

Definition at line 154 of file array_userfuncs.c.

References array_set_element(), Assert, EOHPGetRWDatum, ereport, errcode(), errmsg(), ERROR, fetch_array_arg_replace_nulls(), ExpandedArrayHeader::hdr, ExpandedArrayHeader::lbound, ExpandedArrayHeader::ndims, PG_ARGISNULL, PG_GETARG_DATUM, PG_RETURN_DATUM, pg_sub_s32_overflow(), ArrayMetaState::typalign, ArrayMetaState::typbyval, and ArrayMetaState::typlen.

155 {
156  ExpandedArrayHeader *eah;
157  Datum newelem;
158  bool isNull;
159  Datum result;
160  int *lb;
161  int indx;
162  int lb0;
163  ArrayMetaState *my_extra;
164 
165  isNull = PG_ARGISNULL(0);
166  if (isNull)
167  newelem = (Datum) 0;
168  else
169  newelem = PG_GETARG_DATUM(0);
170  eah = fetch_array_arg_replace_nulls(fcinfo, 1);
171 
172  if (eah->ndims == 1)
173  {
174  /* prepend newelem */
175  lb = eah->lbound;
176  lb0 = lb[0];
177 
178  if (pg_sub_s32_overflow(lb0, 1, &indx))
179  ereport(ERROR,
180  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
181  errmsg("integer out of range")));
182  }
183  else if (eah->ndims == 0)
184  {
185  indx = 1;
186  lb0 = 1;
187  }
188  else
189  ereport(ERROR,
190  (errcode(ERRCODE_DATA_EXCEPTION),
191  errmsg("argument must be empty or one-dimensional array")));
192 
193  /* Perform element insertion */
194  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
195 
196  result = array_set_element(EOHPGetRWDatum(&eah->hdr),
197  1, &indx, newelem, isNull,
198  -1, my_extra->typlen, my_extra->typbyval, my_extra->typalign);
199 
200  /* Readjust result's LB to match the input's, as expected for prepend */
201  Assert(result == EOHPGetRWDatum(&eah->hdr));
202  if (eah->ndims == 1)
203  {
204  /* This is ok whether we've deconstructed or not */
205  eah->lbound[0] = lb0;
206  }
207 
208  PG_RETURN_DATUM(result);
209 }
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:238
int errcode(int sqlerrcode)
Definition: elog.c:575
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:2187
bool typbyval
Definition: array.h:225
static ExpandedArrayHeader * fetch_array_arg_replace_nulls(FunctionCallInfo fcinfo, int argno)
#define ERROR
Definition: elog.h:43
ExpandedObjectHeader hdr
Definition: array.h:106
int16 typlen
Definition: array.h:224
static bool pg_sub_s32_overflow(int32 a, int32 b, int32 *result)
Definition: int.h:121
#define ereport(elevel, rest)
Definition: elog.h:122
uintptr_t Datum
Definition: postgres.h:365
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:318
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
#define Assert(condition)
Definition: c.h:699
char typalign
Definition: array.h:226
#define EOHPGetRWDatum(eohptr)
int errmsg(const char *fmt,...)
Definition: elog.c:797

◆ fetch_array_arg_replace_nulls()

static ExpandedArrayHeader* fetch_array_arg_replace_nulls ( FunctionCallInfo  fcinfo,
int  argno 
)
static

Definition at line 42 of file array_userfuncs.c.

References AggCheckCallContext(), construct_empty_expanded_array(), CurrentMemoryContext, ArrayMetaState::element_type, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, get_element_type(), get_fn_expr_argtype(), InvalidOid, MemoryContextAlloc(), MemoryContextSwitchTo(), OidIsValid, PG_ARGISNULL, and PG_GETARG_EXPANDED_ARRAYX.

Referenced by array_append(), and array_prepend().

43 {
45  Oid element_type;
46  ArrayMetaState *my_extra;
47  MemoryContext resultcxt;
48 
49  /* If first time through, create datatype cache struct */
50  my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
51  if (my_extra == NULL)
52  {
53  my_extra = (ArrayMetaState *)
55  sizeof(ArrayMetaState));
56  my_extra->element_type = InvalidOid;
57  fcinfo->flinfo->fn_extra = my_extra;
58  }
59 
60  /* Figure out which context we want the result in */
61  if (!AggCheckCallContext(fcinfo, &resultcxt))
62  resultcxt = CurrentMemoryContext;
63 
64  /* Now collect the array value */
65  if (!PG_ARGISNULL(argno))
66  {
67  MemoryContext oldcxt = MemoryContextSwitchTo(resultcxt);
68 
69  eah = PG_GETARG_EXPANDED_ARRAYX(argno, my_extra);
70  MemoryContextSwitchTo(oldcxt);
71  }
72  else
73  {
74  /* We have to look up the array type and element type */
75  Oid arr_typeid = get_fn_expr_argtype(fcinfo->flinfo, argno);
76 
77  if (!OidIsValid(arr_typeid))
78  ereport(ERROR,
79  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
80  errmsg("could not determine input data type")));
81  element_type = get_element_type(arr_typeid);
82  if (!OidIsValid(element_type))
83  ereport(ERROR,
84  (errcode(ERRCODE_DATATYPE_MISMATCH),
85  errmsg("input data type is not an array")));
86 
87  eah = construct_empty_expanded_array(element_type,
88  resultcxt,
89  my_extra);
90  }
91 
92  return eah;
93 }
MemoryContext fn_mcxt
Definition: fmgr.h:65
Oid get_element_type(Oid typid)
Definition: lsyscache.c:2502
#define PG_GETARG_EXPANDED_ARRAYX(n, metacache)
Definition: array.h:254
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
int errcode(int sqlerrcode)
Definition: elog.c:575
unsigned int Oid
Definition: postgres_ext.h:31
#define OidIsValid(objectId)
Definition: c.h:605
FmgrInfo * flinfo
Definition: fmgr.h:79
#define ERROR
Definition: elog.h:43
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1994
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
#define ereport(elevel, rest)
Definition: elog.h:122
ExpandedArrayHeader * construct_empty_expanded_array(Oid element_type, MemoryContext parentcontext, ArrayMetaState *metacache)
Definition: arrayfuncs.c:3415
#define InvalidOid
Definition: postgres_ext.h:36
#define PG_ARGISNULL(n)
Definition: fmgr.h:179
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:3492
void * fn_extra
Definition: fmgr.h:64
int errmsg(const char *fmt,...)
Definition: elog.c:797
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:771
Oid element_type
Definition: array.h:223