PostgreSQL Source Code  git master
regress.c
Go to the documentation of this file.
1 /*------------------------------------------------------------------------
2  *
3  * regress.c
4  * Code for various C-language functions defined as part of the
5  * regression tests.
6  *
7  * This code is released under the terms of the PostgreSQL License.
8  *
9  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
10  * Portions Copyright (c) 1994, Regents of the University of California
11  *
12  * src/test/regress/regress.c
13  *
14  *-------------------------------------------------------------------------
15  */
16 
17 #include "postgres.h"
18 
19 #include <math.h>
20 #include <signal.h>
21 
22 #include "access/detoast.h"
23 #include "access/htup_details.h"
24 #include "access/transam.h"
25 #include "access/xact.h"
26 #include "catalog/namespace.h"
27 #include "catalog/pg_operator.h"
28 #include "catalog/pg_type.h"
29 #include "commands/sequence.h"
30 #include "commands/trigger.h"
31 #include "executor/executor.h"
32 #include "executor/spi.h"
33 #include "funcapi.h"
34 #include "mb/pg_wchar.h"
35 #include "miscadmin.h"
36 #include "nodes/supportnodes.h"
37 #include "optimizer/optimizer.h"
38 #include "optimizer/plancat.h"
39 #include "parser/parse_coerce.h"
40 #include "port/atomics.h"
41 #include "storage/spin.h"
42 #include "utils/array.h"
43 #include "utils/builtins.h"
44 #include "utils/geo_decls.h"
45 #include "utils/memutils.h"
46 #include "utils/rel.h"
47 #include "utils/typcache.h"
48 
49 #define EXPECT_TRUE(expr) \
50  do { \
51  if (!(expr)) \
52  elog(ERROR, \
53  "%s was unexpectedly false in file \"%s\" line %u", \
54  #expr, __FILE__, __LINE__); \
55  } while (0)
56 
57 #define EXPECT_EQ_U32(result_expr, expected_expr) \
58  do { \
59  uint32 actual_result = (result_expr); \
60  uint32 expected_result = (expected_expr); \
61  if (actual_result != expected_result) \
62  elog(ERROR, \
63  "%s yielded %u, expected %s in file \"%s\" line %u", \
64  #result_expr, actual_result, #expected_expr, __FILE__, __LINE__); \
65  } while (0)
66 
67 #define EXPECT_EQ_U64(result_expr, expected_expr) \
68  do { \
69  uint64 actual_result = (result_expr); \
70  uint64 expected_result = (expected_expr); \
71  if (actual_result != expected_result) \
72  elog(ERROR, \
73  "%s yielded " UINT64_FORMAT ", expected %s in file \"%s\" line %u", \
74  #result_expr, actual_result, #expected_expr, __FILE__, __LINE__); \
75  } while (0)
76 
77 #define LDELIM '('
78 #define RDELIM ')'
79 #define DELIM ','
80 
81 static void regress_lseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
82 
84 
85 
86 /* return the point where two paths intersect, or NULL if no intersection. */
88 
89 Datum
91 {
92  PATH *p1 = PG_GETARG_PATH_P(0);
93  PATH *p2 = PG_GETARG_PATH_P(1);
94  int i,
95  j;
96  LSEG seg1,
97  seg2;
98  bool found; /* We've found the intersection */
99 
100  found = false; /* Haven't found it yet */
101 
102  for (i = 0; i < p1->npts - 1 && !found; i++)
103  {
104  regress_lseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
105  for (j = 0; j < p2->npts - 1 && !found; j++)
106  {
107  regress_lseg_construct(&seg2, &p2->p[j], &p2->p[j + 1]);
109  LsegPGetDatum(&seg1),
110  LsegPGetDatum(&seg2))))
111  found = true;
112  }
113  }
114 
115  if (!found)
116  PG_RETURN_NULL();
117 
118  /*
119  * Note: DirectFunctionCall2 will kick out an error if lseg_interpt()
120  * returns NULL, but that should be impossible since we know the two
121  * segments intersect.
122  */
124  LsegPGetDatum(&seg1),
125  LsegPGetDatum(&seg2)));
126 }
127 
128 
129 /* like lseg_construct, but assume space already allocated */
130 static void
132 {
133  lseg->p[0].x = pt1->x;
134  lseg->p[0].y = pt1->y;
135  lseg->p[1].x = pt2->x;
136  lseg->p[1].y = pt2->y;
137 }
138 
140 
141 Datum
143 {
145  bool isnull;
146  int32 salary;
147 
148  salary = DatumGetInt32(GetAttributeByName(tuple, "salary", &isnull));
149  if (isnull)
150  PG_RETURN_NULL();
151  PG_RETURN_BOOL(salary > 699);
152 }
153 
154 /* New type "widget"
155  * This used to be "circle", but I added circle to builtins,
156  * so needed to make sure the names do not collide. - tgl 97/04/21
157  */
158 
159 typedef struct
160 {
162  double radius;
163 } WIDGET;
164 
167 
168 #define NARGS 3
169 
170 Datum
172 {
173  char *str = PG_GETARG_CSTRING(0);
174  char *p,
175  *coord[NARGS];
176  int i;
177  WIDGET *result;
178 
179  for (i = 0, p = str; *p && i < NARGS && *p != RDELIM; p++)
180  {
181  if (*p == DELIM || (*p == LDELIM && i == 0))
182  coord[i++] = p + 1;
183  }
184 
185  /*
186  * Note: DON'T convert this error to "soft" style (errsave/ereturn). We
187  * want this data type to stay permanently in the hard-error world so that
188  * it can be used for testing that such cases still work reasonably.
189  */
190  if (i < NARGS)
191  ereport(ERROR,
192  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
193  errmsg("invalid input syntax for type %s: \"%s\"",
194  "widget", str)));
195 
196  result = (WIDGET *) palloc(sizeof(WIDGET));
197  result->center.x = atof(coord[0]);
198  result->center.y = atof(coord[1]);
199  result->radius = atof(coord[2]);
200 
201  PG_RETURN_POINTER(result);
202 }
203 
204 Datum
206 {
207  WIDGET *widget = (WIDGET *) PG_GETARG_POINTER(0);
208  char *str = psprintf("(%g,%g,%g)",
209  widget->center.x, widget->center.y, widget->radius);
210 
212 }
213 
215 
216 Datum
218 {
219  Point *point = PG_GETARG_POINT_P(0);
220  WIDGET *widget = (WIDGET *) PG_GETARG_POINTER(1);
221  float8 distance;
222 
224  PointPGetDatum(point),
225  PointPGetDatum(&widget->center)));
226 
227  PG_RETURN_BOOL(distance < widget->radius);
228 }
229 
231 
232 Datum
234 {
235  char *string = PG_GETARG_CSTRING(0);
236  int i;
237  int len;
238  char *new_string;
239 
240  new_string = palloc0(NAMEDATALEN);
241  for (i = 0; i < NAMEDATALEN && string[i]; ++i)
242  ;
243  if (i == NAMEDATALEN || !string[i])
244  --i;
245  len = i;
246  for (; i >= 0; --i)
247  new_string[len - i] = string[i];
248  PG_RETURN_CSTRING(new_string);
249 }
250 
252 
253 Datum
255 {
256  TriggerData *trigdata = (TriggerData *) fcinfo->context;
257  HeapTuple tuple;
258 
259  if (!CALLED_AS_TRIGGER(fcinfo))
260  elog(ERROR, "trigger_return_old: not fired by trigger manager");
261 
262  tuple = trigdata->tg_trigtuple;
263 
264  return PointerGetDatum(tuple);
265 }
266 
267 #define TTDUMMY_INFINITY 999999
268 
269 static SPIPlanPtr splan = NULL;
270 static bool ttoff = false;
271 
273 
274 Datum
276 {
277  TriggerData *trigdata = (TriggerData *) fcinfo->context;
278  Trigger *trigger; /* to get trigger name */
279  char **args; /* arguments */
280  int attnum[2]; /* fnumbers of start/stop columns */
281  Datum oldon,
282  oldoff;
283  Datum newon,
284  newoff;
285  Datum *cvals; /* column values */
286  char *cnulls; /* column nulls */
287  char *relname; /* triggered relation name */
288  Relation rel; /* triggered relation */
289  HeapTuple trigtuple;
290  HeapTuple newtuple = NULL;
291  HeapTuple rettuple;
292  TupleDesc tupdesc; /* tuple description */
293  int natts; /* # of attributes */
294  bool isnull; /* to know is some column NULL or not */
295  int ret;
296  int i;
297 
298  if (!CALLED_AS_TRIGGER(fcinfo))
299  elog(ERROR, "ttdummy: not fired by trigger manager");
300  if (!TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
301  elog(ERROR, "ttdummy: must be fired for row");
302  if (!TRIGGER_FIRED_BEFORE(trigdata->tg_event))
303  elog(ERROR, "ttdummy: must be fired before event");
304  if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
305  elog(ERROR, "ttdummy: cannot process INSERT event");
306  if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
307  newtuple = trigdata->tg_newtuple;
308 
309  trigtuple = trigdata->tg_trigtuple;
310 
311  rel = trigdata->tg_relation;
312  relname = SPI_getrelname(rel);
313 
314  /* check if TT is OFF for this relation */
315  if (ttoff) /* OFF - nothing to do */
316  {
317  pfree(relname);
318  return PointerGetDatum((newtuple != NULL) ? newtuple : trigtuple);
319  }
320 
321  trigger = trigdata->tg_trigger;
322 
323  if (trigger->tgnargs != 2)
324  elog(ERROR, "ttdummy (%s): invalid (!= 2) number of arguments %d",
325  relname, trigger->tgnargs);
326 
327  args = trigger->tgargs;
328  tupdesc = rel->rd_att;
329  natts = tupdesc->natts;
330 
331  for (i = 0; i < 2; i++)
332  {
333  attnum[i] = SPI_fnumber(tupdesc, args[i]);
334  if (attnum[i] <= 0)
335  elog(ERROR, "ttdummy (%s): there is no attribute %s",
336  relname, args[i]);
337  if (SPI_gettypeid(tupdesc, attnum[i]) != INT4OID)
338  elog(ERROR, "ttdummy (%s): attribute %s must be of integer type",
339  relname, args[i]);
340  }
341 
342  oldon = SPI_getbinval(trigtuple, tupdesc, attnum[0], &isnull);
343  if (isnull)
344  elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[0]);
345 
346  oldoff = SPI_getbinval(trigtuple, tupdesc, attnum[1], &isnull);
347  if (isnull)
348  elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[1]);
349 
350  if (newtuple != NULL) /* UPDATE */
351  {
352  newon = SPI_getbinval(newtuple, tupdesc, attnum[0], &isnull);
353  if (isnull)
354  elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[0]);
355  newoff = SPI_getbinval(newtuple, tupdesc, attnum[1], &isnull);
356  if (isnull)
357  elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[1]);
358 
359  if (oldon != newon || oldoff != newoff)
360  ereport(ERROR,
361  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
362  errmsg("ttdummy (%s): you cannot change %s and/or %s columns (use set_ttdummy)",
363  relname, args[0], args[1])));
364 
365  if (newoff != TTDUMMY_INFINITY)
366  {
367  pfree(relname); /* allocated in upper executor context */
368  return PointerGetDatum(NULL);
369  }
370  }
371  else if (oldoff != TTDUMMY_INFINITY) /* DELETE */
372  {
373  pfree(relname);
374  return PointerGetDatum(NULL);
375  }
376 
377  newoff = DirectFunctionCall1(nextval, CStringGetTextDatum("ttdummy_seq"));
378  /* nextval now returns int64; coerce down to int32 */
379  newoff = Int32GetDatum((int32) DatumGetInt64(newoff));
380 
381  /* Connect to SPI manager */
382  if ((ret = SPI_connect()) < 0)
383  elog(ERROR, "ttdummy (%s): SPI_connect returned %d", relname, ret);
384 
385  /* Fetch tuple values and nulls */
386  cvals = (Datum *) palloc(natts * sizeof(Datum));
387  cnulls = (char *) palloc(natts * sizeof(char));
388  for (i = 0; i < natts; i++)
389  {
390  cvals[i] = SPI_getbinval((newtuple != NULL) ? newtuple : trigtuple,
391  tupdesc, i + 1, &isnull);
392  cnulls[i] = (isnull) ? 'n' : ' ';
393  }
394 
395  /* change date column(s) */
396  if (newtuple) /* UPDATE */
397  {
398  cvals[attnum[0] - 1] = newoff; /* start_date eq current date */
399  cnulls[attnum[0] - 1] = ' ';
400  cvals[attnum[1] - 1] = TTDUMMY_INFINITY; /* stop_date eq INFINITY */
401  cnulls[attnum[1] - 1] = ' ';
402  }
403  else
404  /* DELETE */
405  {
406  cvals[attnum[1] - 1] = newoff; /* stop_date eq current date */
407  cnulls[attnum[1] - 1] = ' ';
408  }
409 
410  /* if there is no plan ... */
411  if (splan == NULL)
412  {
413  SPIPlanPtr pplan;
414  Oid *ctypes;
415  char *query;
416 
417  /* allocate space in preparation */
418  ctypes = (Oid *) palloc(natts * sizeof(Oid));
419  query = (char *) palloc(100 + 16 * natts);
420 
421  /*
422  * Construct query: INSERT INTO _relation_ VALUES ($1, ...)
423  */
424  sprintf(query, "INSERT INTO %s VALUES (", relname);
425  for (i = 1; i <= natts; i++)
426  {
427  sprintf(query + strlen(query), "$%d%s",
428  i, (i < natts) ? ", " : ")");
429  ctypes[i - 1] = SPI_gettypeid(tupdesc, i);
430  }
431 
432  /* Prepare plan for query */
433  pplan = SPI_prepare(query, natts, ctypes);
434  if (pplan == NULL)
435  elog(ERROR, "ttdummy (%s): SPI_prepare returned %s", relname, SPI_result_code_string(SPI_result));
436 
437  if (SPI_keepplan(pplan))
438  elog(ERROR, "ttdummy (%s): SPI_keepplan failed", relname);
439 
440  splan = pplan;
441  }
442 
443  ret = SPI_execp(splan, cvals, cnulls, 0);
444 
445  if (ret < 0)
446  elog(ERROR, "ttdummy (%s): SPI_execp returned %d", relname, ret);
447 
448  /* Tuple to return to upper Executor ... */
449  if (newtuple) /* UPDATE */
450  rettuple = SPI_modifytuple(rel, trigtuple, 1, &(attnum[1]), &newoff, NULL);
451  else /* DELETE */
452  rettuple = trigtuple;
453 
454  SPI_finish(); /* don't forget say Bye to SPI mgr */
455 
456  pfree(relname);
457 
458  return PointerGetDatum(rettuple);
459 }
460 
462 
463 Datum
465 {
466  int32 on = PG_GETARG_INT32(0);
467 
468  if (ttoff) /* OFF currently */
469  {
470  if (on == 0)
471  PG_RETURN_INT32(0);
472 
473  /* turn ON */
474  ttoff = false;
475  PG_RETURN_INT32(0);
476  }
477 
478  /* ON currently */
479  if (on != 0)
480  PG_RETURN_INT32(1);
481 
482  /* turn OFF */
483  ttoff = true;
484 
485  PG_RETURN_INT32(1);
486 }
487 
488 
489 /*
490  * Type int44 has no real-world use, but the regression tests use it
491  * (under the alias "city_budget"). It's a four-element vector of int4's.
492  */
493 
494 /*
495  * int44in - converts "num, num, ..." to internal form
496  *
497  * Note: Fills any missing positions with zeroes.
498  */
500 
501 Datum
503 {
504  char *input_string = PG_GETARG_CSTRING(0);
505  int32 *result = (int32 *) palloc(4 * sizeof(int32));
506  int i;
507 
508  i = sscanf(input_string,
509  "%d, %d, %d, %d",
510  &result[0],
511  &result[1],
512  &result[2],
513  &result[3]);
514  while (i < 4)
515  result[i++] = 0;
516 
517  PG_RETURN_POINTER(result);
518 }
519 
520 /*
521  * int44out - converts internal form to "num, num, ..."
522  */
524 
525 Datum
527 {
528  int32 *an_array = (int32 *) PG_GETARG_POINTER(0);
529  char *result = (char *) palloc(16 * 4);
530 
531  snprintf(result, 16 * 4, "%d,%d,%d,%d",
532  an_array[0],
533  an_array[1],
534  an_array[2],
535  an_array[3]);
536 
537  PG_RETURN_CSTRING(result);
538 }
539 
541 Datum
543 {
544  char *path = text_to_cstring(PG_GETARG_TEXT_PP(0));
545 
546  canonicalize_path(path);
548 }
549 
551 Datum
553 {
555  HeapTupleData tuple;
556  int ncolumns;
557  Datum *values;
558  bool *nulls;
559 
560  Oid tupType;
561  int32 tupTypmod;
562  TupleDesc tupdesc;
563 
564  HeapTuple newtup;
565 
566  int i;
567 
568  MemoryContext old_context;
569 
570  /* Extract type info from the tuple itself */
571  tupType = HeapTupleHeaderGetTypeId(rec);
572  tupTypmod = HeapTupleHeaderGetTypMod(rec);
573  tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
574  ncolumns = tupdesc->natts;
575 
576  /* Build a temporary HeapTuple control structure */
578  ItemPointerSetInvalid(&(tuple.t_self));
579  tuple.t_tableOid = InvalidOid;
580  tuple.t_data = rec;
581 
582  values = (Datum *) palloc(ncolumns * sizeof(Datum));
583  nulls = (bool *) palloc(ncolumns * sizeof(bool));
584 
585  heap_deform_tuple(&tuple, tupdesc, values, nulls);
586 
588 
589  for (i = 0; i < ncolumns; i++)
590  {
591  struct varlena *attr;
592  struct varlena *new_attr;
593  struct varatt_indirect redirect_pointer;
594 
595  /* only work on existing, not-null varlenas */
596  if (TupleDescAttr(tupdesc, i)->attisdropped ||
597  nulls[i] ||
598  TupleDescAttr(tupdesc, i)->attlen != -1 ||
599  TupleDescAttr(tupdesc, i)->attstorage == TYPSTORAGE_PLAIN)
600  continue;
601 
602  attr = (struct varlena *) DatumGetPointer(values[i]);
603 
604  /* don't recursively indirect */
605  if (VARATT_IS_EXTERNAL_INDIRECT(attr))
606  continue;
607 
608  /* copy datum, so it still lives later */
609  if (VARATT_IS_EXTERNAL_ONDISK(attr))
610  attr = detoast_external_attr(attr);
611  else
612  {
613  struct varlena *oldattr = attr;
614 
615  attr = palloc0(VARSIZE_ANY(oldattr));
616  memcpy(attr, oldattr, VARSIZE_ANY(oldattr));
617  }
618 
619  /* build indirection Datum */
620  new_attr = (struct varlena *) palloc0(INDIRECT_POINTER_SIZE);
621  redirect_pointer.pointer = attr;
623  memcpy(VARDATA_EXTERNAL(new_attr), &redirect_pointer,
624  sizeof(redirect_pointer));
625 
626  values[i] = PointerGetDatum(new_attr);
627  }
628 
629  newtup = heap_form_tuple(tupdesc, values, nulls);
630  pfree(values);
631  pfree(nulls);
632  ReleaseTupleDesc(tupdesc);
633 
634  MemoryContextSwitchTo(old_context);
635 
636  /*
637  * We intentionally don't use PG_RETURN_HEAPTUPLEHEADER here, because that
638  * would cause the indirect toast pointers to be flattened out of the
639  * tuple immediately, rendering subsequent testing irrelevant. So just
640  * return the HeapTupleHeader pointer as-is. This violates the general
641  * rule that composite Datums shouldn't contain toast pointers, but so
642  * long as the regression test scripts don't insert the result of this
643  * function into a container type (record, array, etc) it should be OK.
644  */
645  PG_RETURN_POINTER(newtup->t_data);
646 }
647 
649 
650 Datum
652 {
653  char *envvar = text_to_cstring(PG_GETARG_TEXT_PP(0));
654  char *envval = text_to_cstring(PG_GETARG_TEXT_PP(1));
655 
656  if (!superuser())
657  elog(ERROR, "must be superuser to change environment variables");
658 
659  if (setenv(envvar, envval, 1) != 0)
660  elog(ERROR, "could not set environment variable: %m");
661 
662  PG_RETURN_VOID();
663 }
664 
665 /* Sleep until no process has a given PID. */
667 
668 Datum
670 {
671  int pid = PG_GETARG_INT32(0);
672 
673  if (!superuser())
674  elog(ERROR, "must be superuser to check PID liveness");
675 
676  while (kill(pid, 0) == 0)
677  {
679  pg_usleep(50000);
680  }
681 
682  if (errno != ESRCH)
683  elog(ERROR, "could not check PID %d liveness: %m", pid);
684 
685  PG_RETURN_VOID();
686 }
687 
688 static void
690 {
692 
702 }
703 
704 static void
706 {
707  pg_atomic_uint32 var;
708  uint32 expected;
709  int i;
710 
711  pg_atomic_init_u32(&var, 0);
713  pg_atomic_write_u32(&var, 3);
716  3);
719  EXPECT_EQ_U32(pg_atomic_add_fetch_u32(&var, 10), 10);
722 
723  /* test around numerical limits */
724  EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, INT_MAX), 0);
725  EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&var, INT_MAX), INT_MAX);
726  pg_atomic_fetch_add_u32(&var, 2); /* wrap to 0 */
729  PG_INT16_MAX);
731  2 * PG_INT16_MAX + 1);
733  PG_INT16_MAX);
734  pg_atomic_fetch_add_u32(&var, 1); /* top up to UINT_MAX */
735  EXPECT_EQ_U32(pg_atomic_read_u32(&var), UINT_MAX);
736  EXPECT_EQ_U32(pg_atomic_fetch_sub_u32(&var, INT_MAX), UINT_MAX);
737  EXPECT_EQ_U32(pg_atomic_read_u32(&var), (uint32) INT_MAX + 1);
738  EXPECT_EQ_U32(pg_atomic_sub_fetch_u32(&var, INT_MAX), 1);
739  pg_atomic_sub_fetch_u32(&var, 1);
740  expected = PG_INT16_MAX;
741  EXPECT_TRUE(!pg_atomic_compare_exchange_u32(&var, &expected, 1));
742  expected = PG_INT16_MAX + 1;
743  EXPECT_TRUE(!pg_atomic_compare_exchange_u32(&var, &expected, 1));
744  expected = PG_INT16_MIN;
745  EXPECT_TRUE(!pg_atomic_compare_exchange_u32(&var, &expected, 1));
746  expected = PG_INT16_MIN - 1;
747  EXPECT_TRUE(!pg_atomic_compare_exchange_u32(&var, &expected, 1));
748 
749  /* fail exchange because of old expected */
750  expected = 10;
751  EXPECT_TRUE(!pg_atomic_compare_exchange_u32(&var, &expected, 1));
752 
753  /* CAS is allowed to fail due to interrupts, try a couple of times */
754  for (i = 0; i < 1000; i++)
755  {
756  expected = 0;
757  if (!pg_atomic_compare_exchange_u32(&var, &expected, 1))
758  break;
759  }
760  if (i == 1000)
761  elog(ERROR, "atomic_compare_exchange_u32() never succeeded");
763  pg_atomic_write_u32(&var, 0);
764 
765  /* try setting flagbits */
766  EXPECT_TRUE(!(pg_atomic_fetch_or_u32(&var, 1) & 1));
767  EXPECT_TRUE(pg_atomic_fetch_or_u32(&var, 2) & 1);
769  /* try clearing flagbits */
770  EXPECT_EQ_U32(pg_atomic_fetch_and_u32(&var, ~2) & 3, 3);
772  /* no bits set anymore */
774 }
775 
776 static void
778 {
779  pg_atomic_uint64 var;
780  uint64 expected;
781  int i;
782 
783  pg_atomic_init_u64(&var, 0);
785  pg_atomic_write_u64(&var, 3);
788  3);
791  EXPECT_EQ_U64(pg_atomic_add_fetch_u64(&var, 10), 10);
794 
795  /* fail exchange because of old expected */
796  expected = 10;
797  EXPECT_TRUE(!pg_atomic_compare_exchange_u64(&var, &expected, 1));
798 
799  /* CAS is allowed to fail due to interrupts, try a couple of times */
800  for (i = 0; i < 100; i++)
801  {
802  expected = 0;
803  if (!pg_atomic_compare_exchange_u64(&var, &expected, 1))
804  break;
805  }
806  if (i == 100)
807  elog(ERROR, "atomic_compare_exchange_u64() never succeeded");
809 
810  pg_atomic_write_u64(&var, 0);
811 
812  /* try setting flagbits */
813  EXPECT_TRUE(!(pg_atomic_fetch_or_u64(&var, 1) & 1));
814  EXPECT_TRUE(pg_atomic_fetch_or_u64(&var, 2) & 1);
816  /* try clearing flagbits */
817  EXPECT_EQ_U64((pg_atomic_fetch_and_u64(&var, ~2) & 3), 3);
819  /* no bits set anymore */
821 }
822 
823 /*
824  * Perform, fairly minimal, testing of the spinlock implementation.
825  *
826  * It's likely worth expanding these to actually test concurrency etc, but
827  * having some regularly run tests is better than none.
828  */
829 static void
831 {
832  /*
833  * Basic tests for spinlocks, as well as the underlying operations.
834  *
835  * We embed the spinlock in a struct with other members to test that the
836  * spinlock operations don't perform too wide writes.
837  */
838  {
839  struct test_lock_struct
840  {
841  char data_before[4];
842  slock_t lock;
843  char data_after[4];
844  } struct_w_lock;
845 
846  memcpy(struct_w_lock.data_before, "abcd", 4);
847  memcpy(struct_w_lock.data_after, "ef12", 4);
848 
849  /* test basic operations via the SpinLock* API */
850  SpinLockInit(&struct_w_lock.lock);
851  SpinLockAcquire(&struct_w_lock.lock);
852  SpinLockRelease(&struct_w_lock.lock);
853 
854  /* test basic operations via underlying S_* API */
855  S_INIT_LOCK(&struct_w_lock.lock);
856  S_LOCK(&struct_w_lock.lock);
857  S_UNLOCK(&struct_w_lock.lock);
858 
859  /* and that "contended" acquisition works */
860  s_lock(&struct_w_lock.lock, "testfile", 17, "testfunc");
861  S_UNLOCK(&struct_w_lock.lock);
862 
863  /*
864  * Check, using TAS directly, that a single spin cycle doesn't block
865  * when acquiring an already acquired lock.
866  */
867 #ifdef TAS
868  S_LOCK(&struct_w_lock.lock);
869 
870  if (!TAS(&struct_w_lock.lock))
871  elog(ERROR, "acquired already held spinlock");
872 
873 #ifdef TAS_SPIN
874  if (!TAS_SPIN(&struct_w_lock.lock))
875  elog(ERROR, "acquired already held spinlock");
876 #endif /* defined(TAS_SPIN) */
877 
878  S_UNLOCK(&struct_w_lock.lock);
879 #endif /* defined(TAS) */
880 
881  /*
882  * Verify that after all of this the non-lock contents are still
883  * correct.
884  */
885  if (memcmp(struct_w_lock.data_before, "abcd", 4) != 0)
886  elog(ERROR, "padding before spinlock modified");
887  if (memcmp(struct_w_lock.data_after, "ef12", 4) != 0)
888  elog(ERROR, "padding after spinlock modified");
889  }
890 
891  /*
892  * Ensure that allocating more than INT32_MAX emulated spinlocks works.
893  * That's interesting because the spinlock emulation uses a 32bit integer
894  * to map spinlocks onto semaphores. There've been bugs...
895  */
896 #ifndef HAVE_SPINLOCKS
897  {
898  /*
899  * Initialize enough spinlocks to advance counter close to wraparound.
900  * It's too expensive to perform acquire/release for each, as those
901  * may be syscalls when the spinlock emulation is used (and even just
902  * atomic TAS would be expensive).
903  */
904  for (uint32 i = 0; i < INT32_MAX - 100000; i++)
905  {
906  slock_t lock;
907 
908  SpinLockInit(&lock);
909  }
910 
911  for (uint32 i = 0; i < 200000; i++)
912  {
913  slock_t lock;
914 
915  SpinLockInit(&lock);
916 
917  SpinLockAcquire(&lock);
918  SpinLockRelease(&lock);
919  SpinLockAcquire(&lock);
920  SpinLockRelease(&lock);
921  }
922  }
923 #endif
924 }
925 
926 /*
927  * Verify that performing atomic ops inside a spinlock isn't a
928  * problem. Realistically that's only going to be a problem when both
929  * --disable-spinlocks and --disable-atomics are used, but it's cheap enough
930  * to just always test.
931  *
932  * The test works by initializing enough atomics that we'd conflict if there
933  * were an overlap between a spinlock and an atomic by holding a spinlock
934  * while manipulating more than NUM_SPINLOCK_SEMAPHORES atomics.
935  *
936  * NUM_TEST_ATOMICS doesn't really need to be more than
937  * NUM_SPINLOCK_SEMAPHORES, but it seems better to test a bit more
938  * extensively.
939  */
940 static void
942 {
943  slock_t lock;
944 #define NUM_TEST_ATOMICS (NUM_SPINLOCK_SEMAPHORES + NUM_ATOMICS_SEMAPHORES + 27)
947 
948  SpinLockInit(&lock);
949 
950  for (int i = 0; i < NUM_TEST_ATOMICS; i++)
951  {
952  pg_atomic_init_u32(&atomics32[i], 0);
953  pg_atomic_init_u64(&atomics64[i], 0);
954  }
955 
956  /* just so it's not all zeroes */
957  for (int i = 0; i < NUM_TEST_ATOMICS; i++)
958  {
959  EXPECT_EQ_U32(pg_atomic_fetch_add_u32(&atomics32[i], i), 0);
960  EXPECT_EQ_U64(pg_atomic_fetch_add_u64(&atomics64[i], i), 0);
961  }
962 
963  /* test whether we can do atomic op with lock held */
964  SpinLockAcquire(&lock);
965  for (int i = 0; i < NUM_TEST_ATOMICS; i++)
966  {
967  EXPECT_EQ_U32(pg_atomic_fetch_sub_u32(&atomics32[i], i), i);
968  EXPECT_EQ_U32(pg_atomic_read_u32(&atomics32[i]), 0);
969  EXPECT_EQ_U64(pg_atomic_fetch_sub_u64(&atomics64[i], i), i);
970  EXPECT_EQ_U64(pg_atomic_read_u64(&atomics64[i]), 0);
971  }
972  SpinLockRelease(&lock);
973 }
974 #undef NUM_TEST_ATOMICS
975 
977 Datum
979 {
981 
983 
985 
986  /*
987  * Arguably this shouldn't be tested as part of this function, but it's
988  * closely enough related that that seems ok for now.
989  */
990  test_spinlock();
991 
993 
994  PG_RETURN_BOOL(true);
995 }
996 
998 Datum
1000 {
1001  elog(ERROR, "test_fdw_handler is not implemented");
1002  PG_RETURN_NULL();
1003 }
1004 
1006 Datum
1008 {
1009  Node *rawreq = (Node *) PG_GETARG_POINTER(0);
1010  Node *ret = NULL;
1011 
1012  if (IsA(rawreq, SupportRequestSelectivity))
1013  {
1014  /*
1015  * Assume that the target is int4eq; that's safe as long as we don't
1016  * attach this to any other boolean-returning function.
1017  */
1019  Selectivity s1;
1020 
1021  if (req->is_join)
1022  s1 = join_selectivity(req->root, Int4EqualOperator,
1023  req->args,
1024  req->inputcollid,
1025  req->jointype,
1026  req->sjinfo);
1027  else
1028  s1 = restriction_selectivity(req->root, Int4EqualOperator,
1029  req->args,
1030  req->inputcollid,
1031  req->varRelid);
1032 
1033  req->selectivity = s1;
1034  ret = (Node *) req;
1035  }
1036 
1037  if (IsA(rawreq, SupportRequestCost))
1038  {
1039  /* Provide some generic estimate */
1040  SupportRequestCost *req = (SupportRequestCost *) rawreq;
1041 
1042  req->startup = 0;
1043  req->per_tuple = 2 * cpu_operator_cost;
1044  ret = (Node *) req;
1045  }
1046 
1047  if (IsA(rawreq, SupportRequestRows))
1048  {
1049  /*
1050  * Assume that the target is generate_series_int4; that's safe as long
1051  * as we don't attach this to any other set-returning function.
1052  */
1053  SupportRequestRows *req = (SupportRequestRows *) rawreq;
1054 
1055  if (req->node && IsA(req->node, FuncExpr)) /* be paranoid */
1056  {
1057  List *args = ((FuncExpr *) req->node)->args;
1058  Node *arg1 = linitial(args);
1059  Node *arg2 = lsecond(args);
1060 
1061  if (IsA(arg1, Const) &&
1062  !((Const *) arg1)->constisnull &&
1063  IsA(arg2, Const) &&
1064  !((Const *) arg2)->constisnull)
1065  {
1066  int32 val1 = DatumGetInt32(((Const *) arg1)->constvalue);
1067  int32 val2 = DatumGetInt32(((Const *) arg2)->constvalue);
1068 
1069  req->rows = val2 - val1 + 1;
1070  ret = (Node *) req;
1071  }
1072  }
1073  }
1074 
1075  PG_RETURN_POINTER(ret);
1076 }
1077 
1079 Datum
1081 {
1082  PG_RETURN_NULL();
1083 }
1084 
1085 /*
1086  * Call an encoding conversion or verification function.
1087  *
1088  * Arguments:
1089  * string bytea -- string to convert
1090  * src_enc name -- source encoding
1091  * dest_enc name -- destination encoding
1092  * noError bool -- if set, don't ereport() on invalid or untranslatable
1093  * input
1094  *
1095  * Result is a tuple with two attributes:
1096  * int4 -- number of input bytes successfully converted
1097  * bytea -- converted string
1098  */
1100 Datum
1102 {
1103  bytea *string = PG_GETARG_BYTEA_PP(0);
1104  char *src_encoding_name = NameStr(*PG_GETARG_NAME(1));
1105  int src_encoding = pg_char_to_encoding(src_encoding_name);
1106  char *dest_encoding_name = NameStr(*PG_GETARG_NAME(2));
1107  int dest_encoding = pg_char_to_encoding(dest_encoding_name);
1108  bool noError = PG_GETARG_BOOL(3);
1109  TupleDesc tupdesc;
1110  char *src;
1111  char *dst;
1112  bytea *retval;
1113  Size srclen;
1114  Size dstsize;
1115  Oid proc;
1116  int convertedbytes;
1117  int dstlen;
1118  Datum values[2];
1119  bool nulls[2] = {0};
1120  HeapTuple tuple;
1121 
1122  if (src_encoding < 0)
1123  ereport(ERROR,
1124  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1125  errmsg("invalid source encoding name \"%s\"",
1126  src_encoding_name)));
1127  if (dest_encoding < 0)
1128  ereport(ERROR,
1129  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1130  errmsg("invalid destination encoding name \"%s\"",
1131  dest_encoding_name)));
1132 
1133  /* Build a tuple descriptor for our result type */
1134  if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
1135  elog(ERROR, "return type must be a row type");
1136  tupdesc = BlessTupleDesc(tupdesc);
1137 
1138  srclen = VARSIZE_ANY_EXHDR(string);
1139  src = VARDATA_ANY(string);
1140 
1141  if (src_encoding == dest_encoding)
1142  {
1143  /* just check that the source string is valid */
1144  int oklen;
1145 
1146  oklen = pg_encoding_verifymbstr(src_encoding, src, srclen);
1147 
1148  if (oklen == srclen)
1149  {
1150  convertedbytes = oklen;
1151  retval = string;
1152  }
1153  else if (!noError)
1154  {
1155  report_invalid_encoding(src_encoding, src + oklen, srclen - oklen);
1156  }
1157  else
1158  {
1159  /*
1160  * build bytea data type structure.
1161  */
1162  Assert(oklen < srclen);
1163  convertedbytes = oklen;
1164  retval = (bytea *) palloc(oklen + VARHDRSZ);
1165  SET_VARSIZE(retval, oklen + VARHDRSZ);
1166  memcpy(VARDATA(retval), src, oklen);
1167  }
1168  }
1169  else
1170  {
1171  proc = FindDefaultConversionProc(src_encoding, dest_encoding);
1172  if (!OidIsValid(proc))
1173  ereport(ERROR,
1174  (errcode(ERRCODE_UNDEFINED_FUNCTION),
1175  errmsg("default conversion function for encoding \"%s\" to \"%s\" does not exist",
1176  pg_encoding_to_char(src_encoding),
1177  pg_encoding_to_char(dest_encoding))));
1178 
1179  if (srclen >= (MaxAllocSize / (Size) MAX_CONVERSION_GROWTH))
1180  ereport(ERROR,
1181  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1182  errmsg("out of memory"),
1183  errdetail("String of %d bytes is too long for encoding conversion.",
1184  (int) srclen)));
1185 
1186  dstsize = (Size) srclen * MAX_CONVERSION_GROWTH + 1;
1187  dst = MemoryContextAlloc(CurrentMemoryContext, dstsize);
1188 
1189  /* perform conversion */
1190  convertedbytes = pg_do_encoding_conversion_buf(proc,
1191  src_encoding,
1192  dest_encoding,
1193  (unsigned char *) src, srclen,
1194  (unsigned char *) dst, dstsize,
1195  noError);
1196  dstlen = strlen(dst);
1197 
1198  /*
1199  * build bytea data type structure.
1200  */
1201  retval = (bytea *) palloc(dstlen + VARHDRSZ);
1202  SET_VARSIZE(retval, dstlen + VARHDRSZ);
1203  memcpy(VARDATA(retval), dst, dstlen);
1204 
1205  pfree(dst);
1206  }
1207 
1208  values[0] = Int32GetDatum(convertedbytes);
1209  values[1] = PointerGetDatum(retval);
1210  tuple = heap_form_tuple(tupdesc, values, nulls);
1211 
1213 }
1214 
1215 /* Provide SQL access to IsBinaryCoercible() */
1217 Datum
1219 {
1220  Oid srctype = PG_GETARG_OID(0);
1221  Oid targettype = PG_GETARG_OID(1);
1222 
1223  PG_RETURN_BOOL(IsBinaryCoercible(srctype, targettype));
1224 }
static uint32 pg_atomic_fetch_and_u32(volatile pg_atomic_uint32 *ptr, uint32 and_)
Definition: atomics.h:389
static bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval)
Definition: atomics.h:342
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:478
static void pg_atomic_clear_flag(volatile pg_atomic_flag *ptr)
Definition: atomics.h:200
static uint32 pg_atomic_fetch_or_u32(volatile pg_atomic_uint32 *ptr, uint32 or_)
Definition: atomics.h:403
static uint32 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:432
static uint32 pg_atomic_fetch_sub_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:374
static bool pg_atomic_compare_exchange_u64(volatile pg_atomic_uint64 *ptr, uint64 *expected, uint64 newval)
Definition: atomics.h:505
static void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition: atomics.h:214
static uint32 pg_atomic_fetch_add_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:359
static uint32 pg_atomic_add_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:417
static uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
Definition: atomics.h:515
static bool pg_atomic_test_set_flag(volatile pg_atomic_flag *ptr)
Definition: atomics.h:176
static uint64 pg_atomic_sub_fetch_u64(volatile pg_atomic_uint64 *ptr, int64 sub_)
Definition: atomics.h:561
static bool pg_atomic_unlocked_test_flag(volatile pg_atomic_flag *ptr)
Definition: atomics.h:189
static void pg_atomic_write_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition: atomics.h:269
static uint64 pg_atomic_fetch_and_u64(volatile pg_atomic_uint64 *ptr, uint64 and_)
Definition: atomics.h:534
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:232
static uint64 pg_atomic_fetch_or_u64(volatile pg_atomic_uint64 *ptr, uint64 or_)
Definition: atomics.h:543
static uint64 pg_atomic_add_fetch_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
Definition: atomics.h:552
static uint32 pg_atomic_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 newval)
Definition: atomics.h:323
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:446
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:460
static uint64 pg_atomic_fetch_sub_u64(volatile pg_atomic_uint64 *ptr, int64 sub_)
Definition: atomics.h:524
static uint64 pg_atomic_exchange_u64(volatile pg_atomic_uint64 *ptr, uint64 newval)
Definition: atomics.h:496
static void pg_atomic_init_flag(volatile pg_atomic_flag *ptr)
Definition: atomics.h:163
static Datum values[MAXATTR]
Definition: bootstrap.c:150
#define CStringGetTextDatum(s)
Definition: builtins.h:97
#define NameStr(name)
Definition: c.h:746
unsigned int uint32
Definition: c.h:506
signed int int32
Definition: c.h:494
#define VARHDRSZ
Definition: c.h:692
#define Assert(condition)
Definition: c.h:858
double float8
Definition: c.h:630
#define PG_INT16_MIN
Definition: c.h:585
#define PG_INT16_MAX
Definition: c.h:586
#define OidIsValid(objectId)
Definition: c.h:775
size_t Size
Definition: c.h:605
Datum nextval(PG_FUNCTION_ARGS)
Definition: sequence.c:593
double cpu_operator_cost
Definition: costsize.c:123
struct varlena * detoast_external_attr(struct varlena *attr)
Definition: detoast.c:45
#define INDIRECT_POINTER_SIZE
Definition: detoast.h:34
int errdetail(const char *fmt,...)
Definition: elog.c:1205
int errcode(int sqlerrcode)
Definition: elog.c:855
int errmsg(const char *fmt,...)
Definition: elog.c:1072
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2158
Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
Definition: execUtils.c:995
#define PG_RETURN_VOID()
Definition: fmgr.h:349
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:308
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define DirectFunctionCall2(func, arg1, arg2)
Definition: fmgr.h:644
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
#define PG_RETURN_CSTRING(x)
Definition: fmgr.h:362
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:642
#define PG_GETARG_CSTRING(n)
Definition: fmgr.h:277
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_GETARG_NAME(n)
Definition: fmgr.h:278
#define PG_GETARG_HEAPTUPLEHEADER(n)
Definition: fmgr.h:312
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:372
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:274
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:361
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:276
@ TYPEFUNC_COMPOSITE
Definition: funcapi.h:149
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition: funcapi.h:230
#define PG_GETARG_POINT_P(n)
Definition: geo_decls.h:185
static Datum LsegPGetDatum(const LSEG *X)
Definition: geo_decls.h:194
static Datum PointPGetDatum(const Point *X)
Definition: geo_decls.h:181
#define PG_GETARG_PATH_P(n)
Definition: geo_decls.h:216
Datum point_distance(PG_FUNCTION_ARGS)
Definition: geo_ops.c:1993
Datum lseg_intersect(PG_FUNCTION_ARGS)
Definition: geo_ops.c:2188
Datum lseg_interpt(PG_FUNCTION_ARGS)
Definition: geo_ops.c:2361
const char * str
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1116
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1345
#define HeapTupleHeaderGetTypMod(tup)
Definition: htup_details.h:466
#define HeapTupleHeaderGetTypeId(tup)
Definition: htup_details.h:456
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:450
int j
Definition: isn.c:74
int i
Definition: isn.c:73
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
int pg_do_encoding_conversion_buf(Oid proc, int src_encoding, int dest_encoding, unsigned char *src, int srclen, unsigned char *dest, int destlen, bool noError)
Definition: mbutils.c:469
void report_invalid_encoding(int encoding, const char *mbstr, int len)
Definition: mbutils.c:1698
MemoryContext TopTransactionContext
Definition: mcxt.c:154
void pfree(void *pointer)
Definition: mcxt.c:1521
void * palloc0(Size size)
Definition: mcxt.c:1347
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
void * palloc(Size size)
Definition: mcxt.c:1317
#define MaxAllocSize
Definition: memutils.h:40
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
Oid FindDefaultConversionProc(int32 for_encoding, int32 to_encoding)
Definition: namespace.c:4065
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
double Selectivity
Definition: nodes.h:250
bool IsBinaryCoercible(Oid srctype, Oid targettype)
char attstorage
Definition: pg_attribute.h:117
int16 attnum
Definition: pg_attribute.h:74
int16 attlen
Definition: pg_attribute.h:59
NameData relname
Definition: pg_class.h:38
#define NAMEDATALEN
const void size_t len
#define linitial(l)
Definition: pg_list.h:178
#define lsecond(l)
Definition: pg_list.h:183
#define MAX_CONVERSION_GROWTH
Definition: pg_wchar.h:302
#define pg_encoding_to_char
Definition: pg_wchar.h:630
#define pg_char_to_encoding
Definition: pg_wchar.h:629
Selectivity restriction_selectivity(PlannerInfo *root, Oid operatorid, List *args, Oid inputcollid, int varRelid)
Definition: plancat.c:1935
Selectivity join_selectivity(PlannerInfo *root, Oid operatorid, List *args, Oid inputcollid, JoinType jointype, SpecialJoinInfo *sjinfo)
Definition: plancat.c:1974
#define sprintf
Definition: port.h:240
void canonicalize_path(char *path)
Definition: path.c:264
#define snprintf
Definition: port.h:238
static bool DatumGetBool(Datum X)
Definition: postgres.h:90
static int64 DatumGetInt64(Datum X)
Definition: postgres.h:385
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
static float8 DatumGetFloat8(Datum X)
Definition: postgres.h:494
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:202
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
char * s1
char string[11]
Definition: preproc-type.c:52
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
MemoryContextSwitchTo(old_ctx)
static void test_spinlock(void)
Definition: regress.c:830
#define DELIM
Definition: regress.c:79
#define EXPECT_TRUE(expr)
Definition: regress.c:49
static SPIPlanPtr splan
Definition: regress.c:269
Datum regress_setenv(PG_FUNCTION_ARGS)
Definition: regress.c:651
static void test_atomic_spin_nest(void)
Definition: regress.c:941
static void test_atomic_uint32(void)
Definition: regress.c:705
Datum ttdummy(PG_FUNCTION_ARGS)
Definition: regress.c:275
#define TTDUMMY_INFINITY
Definition: regress.c:267
#define EXPECT_EQ_U32(result_expr, expected_expr)
Definition: regress.c:57
#define NUM_TEST_ATOMICS
Datum test_atomic_ops(PG_FUNCTION_ARGS)
Definition: regress.c:978
Datum test_support_func(PG_FUNCTION_ARGS)
Definition: regress.c:1007
PG_FUNCTION_INFO_V1(interpt_pp)
PG_MODULE_MAGIC
Definition: regress.c:83
Datum int44out(PG_FUNCTION_ARGS)
Definition: regress.c:526
Datum set_ttdummy(PG_FUNCTION_ARGS)
Definition: regress.c:464
Datum test_opclass_options_func(PG_FUNCTION_ARGS)
Definition: regress.c:1080
Datum test_fdw_handler(PG_FUNCTION_ARGS)
Definition: regress.c:999
#define EXPECT_EQ_U64(result_expr, expected_expr)
Definition: regress.c:67
Datum interpt_pp(PG_FUNCTION_ARGS)
Definition: regress.c:90
static void regress_lseg_construct(LSEG *lseg, Point *pt1, Point *pt2)
Definition: regress.c:131
Datum trigger_return_old(PG_FUNCTION_ARGS)
Definition: regress.c:254
static bool ttoff
Definition: regress.c:270
#define RDELIM
Definition: regress.c:78
Datum int44in(PG_FUNCTION_ARGS)
Definition: regress.c:502
Datum test_canonicalize_path(PG_FUNCTION_ARGS)
Definition: regress.c:542
Datum reverse_name(PG_FUNCTION_ARGS)
Definition: regress.c:233
Datum widget_in(PG_FUNCTION_ARGS)
Definition: regress.c:171
Datum wait_pid(PG_FUNCTION_ARGS)
Definition: regress.c:669
Datum widget_out(PG_FUNCTION_ARGS)
Definition: regress.c:205
static void test_atomic_flag(void)
Definition: regress.c:689
Datum pt_in_widget(PG_FUNCTION_ARGS)
Definition: regress.c:217
Datum test_enc_conversion(PG_FUNCTION_ARGS)
Definition: regress.c:1101
static void test_atomic_uint64(void)
Definition: regress.c:777
Datum make_tuple_indirect(PG_FUNCTION_ARGS)
Definition: regress.c:552
Datum binary_coercible(PG_FUNCTION_ARGS)
Definition: regress.c:1218
#define LDELIM
Definition: regress.c:77
#define NARGS
Definition: regress.c:168
Datum overpaid(PG_FUNCTION_ARGS)
Definition: regress.c:142
int s_lock(volatile slock_t *lock, const char *file, int line, const char *func)
Definition: s_lock.c:99
#define TAS(lock)
Definition: s_lock.h:680
#define S_UNLOCK(lock)
Definition: s_lock.h:678
#define TAS_SPIN(lock)
Definition: s_lock.h:737
#define S_INIT_LOCK(lock)
Definition: s_lock.h:679
#define S_LOCK(lock)
Definition: s_lock.h:691
int slock_t
Definition: s_lock.h:670
void pg_usleep(long microsec)
Definition: signal.c:53
char * SPI_getrelname(Relation rel)
Definition: spi.c:1323
int SPI_fnumber(TupleDesc tupdesc, const char *fname)
Definition: spi.c:1172
Oid SPI_gettypeid(TupleDesc tupdesc, int fnumber)
Definition: spi.c:1305
int SPI_connect(void)
Definition: spi.c:94
int SPI_result
Definition: spi.c:46
const char * SPI_result_code_string(int code)
Definition: spi.c:1969
int SPI_finish(void)
Definition: spi.c:182
HeapTuple SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum, Datum *Values, const char *Nulls)
Definition: spi.c:1103
SPIPlanPtr SPI_prepare(const char *src, int nargs, Oid *argtypes)
Definition: spi.c:857
int SPI_keepplan(SPIPlanPtr plan)
Definition: spi.c:973
int SPI_execp(SPIPlanPtr plan, Datum *Values, const char *Nulls, long tcount)
Definition: spi.c:701
Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
Definition: spi.c:1249
#define SpinLockInit(lock)
Definition: spin.h:60
#define SpinLockRelease(lock)
Definition: spin.h:64
#define SpinLockAcquire(lock)
Definition: spin.h:62
ItemPointerData t_self
Definition: htup.h:65
uint32 t_len
Definition: htup.h:64
HeapTupleHeader t_data
Definition: htup.h:68
Oid t_tableOid
Definition: htup.h:66
Point p[2]
Definition: geo_decls.h:108
Definition: pg_list.h:54
Definition: nodes.h:129
Point p[FLEXIBLE_ARRAY_MEMBER]
Definition: geo_decls.h:121
int32 npts
Definition: geo_decls.h:118
float8 y
Definition: geo_decls.h:99
float8 x
Definition: geo_decls.h:98
struct PlannerInfo * root
Definition: supportnodes.h:96
struct SpecialJoinInfo * sjinfo
Definition: supportnodes.h:103
Relation tg_relation
Definition: trigger.h:35
TriggerEvent tg_event
Definition: trigger.h:34
HeapTuple tg_newtuple
Definition: trigger.h:37
Trigger * tg_trigger
Definition: trigger.h:38
HeapTuple tg_trigtuple
Definition: trigger.h:36
Point center
Definition: regress.c:161
double radius
Definition: regress.c:162
struct varlena * pointer
Definition: varatt.h:59
Definition: c.h:687
bool superuser(void)
Definition: superuser.c:46
char * flag(int b)
Definition: test-ctype.c:33
#define TRIGGER_FIRED_BEFORE(event)
Definition: trigger.h:128
#define CALLED_AS_TRIGGER(fcinfo)
Definition: trigger.h:26
#define TRIGGER_FIRED_FOR_ROW(event)
Definition: trigger.h:122
#define TRIGGER_FIRED_BY_INSERT(event)
Definition: trigger.h:110
#define TRIGGER_FIRED_BY_UPDATE(event)
Definition: trigger.h:116
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition: typcache.c:1833
#define VARATT_IS_EXTERNAL_ONDISK(PTR)
Definition: varatt.h:290
#define VARATT_IS_EXTERNAL_INDIRECT(PTR)
Definition: varatt.h:292
#define VARSIZE_ANY(PTR)
Definition: varatt.h:311
#define VARDATA(PTR)
Definition: varatt.h:278
#define SET_VARTAG_EXTERNAL(PTR, tag)
Definition: varatt.h:309
#define VARDATA_ANY(PTR)
Definition: varatt.h:324
#define VARDATA_EXTERNAL(PTR)
Definition: varatt.h:286
#define SET_VARSIZE(PTR, len)
Definition: varatt.h:305
@ VARTAG_INDIRECT
Definition: varatt.h:86
#define VARSIZE_ANY_EXHDR(PTR)
Definition: varatt.h:317
char * text_to_cstring(const text *t)
Definition: varlena.c:217
text * cstring_to_text(const char *s)
Definition: varlena.c:184
int pg_encoding_verifymbstr(int encoding, const char *mbstr, int len)
Definition: wchar.c:2116
#define kill(pid, sig)
Definition: win32_port.h:490
#define setenv(x, y, z)
Definition: win32_port.h:542