PostgreSQL Source Code  git master
misc.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * misc.c
4  *
5  *
6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/utils/adt/misc.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include <sys/file.h>
18 #include <sys/stat.h>
19 #include <dirent.h>
20 #include <fcntl.h>
21 #include <math.h>
22 #include <unistd.h>
23 
24 #include "access/sysattr.h"
25 #include "access/table.h"
26 #include "catalog/catalog.h"
27 #include "catalog/pg_tablespace.h"
28 #include "catalog/pg_type.h"
29 #include "catalog/system_fk_info.h"
30 #include "commands/dbcommands.h"
31 #include "commands/tablespace.h"
32 #include "common/keywords.h"
33 #include "funcapi.h"
34 #include "miscadmin.h"
35 #include "nodes/miscnodes.h"
36 #include "parser/parse_type.h"
37 #include "parser/scansup.h"
38 #include "pgstat.h"
39 #include "postmaster/syslogger.h"
40 #include "rewrite/rewriteHandler.h"
41 #include "storage/fd.h"
42 #include "storage/latch.h"
43 #include "tcop/tcopprot.h"
44 #include "utils/builtins.h"
45 #include "utils/fmgroids.h"
46 #include "utils/lsyscache.h"
47 #include "utils/ruleutils.h"
48 #include "utils/timestamp.h"
49 
50 
51 /*
52  * structure to cache metadata needed in pg_input_is_valid_common
53  */
54 typedef struct ValidIOData
55 {
63 
65  text *txt, text *typname,
66  ErrorSaveContext *escontext);
67 
68 
69 /*
70  * Common subroutine for num_nulls() and num_nonnulls().
71  * Returns true if successful, false if function should return NULL.
72  * If successful, total argument count and number of nulls are
73  * returned into *nargs and *nulls.
74  */
75 static bool
77  int32 *nargs, int32 *nulls)
78 {
79  int32 count = 0;
80  int i;
81 
82  /* Did we get a VARIADIC array argument, or separate arguments? */
83  if (get_fn_expr_variadic(fcinfo->flinfo))
84  {
85  ArrayType *arr;
86  int ndims,
87  nitems,
88  *dims;
89  bits8 *bitmap;
90 
91  Assert(PG_NARGS() == 1);
92 
93  /*
94  * If we get a null as VARIADIC array argument, we can't say anything
95  * useful about the number of elements, so return NULL. This behavior
96  * is consistent with other variadic functions - see concat_internal.
97  */
98  if (PG_ARGISNULL(0))
99  return false;
100 
101  /*
102  * Non-null argument had better be an array. We assume that any call
103  * context that could let get_fn_expr_variadic return true will have
104  * checked that a VARIADIC-labeled parameter actually is an array. So
105  * it should be okay to just Assert that it's an array rather than
106  * doing a full-fledged error check.
107  */
109 
110  /* OK, safe to fetch the array value */
111  arr = PG_GETARG_ARRAYTYPE_P(0);
112 
113  /* Count the array elements */
114  ndims = ARR_NDIM(arr);
115  dims = ARR_DIMS(arr);
116  nitems = ArrayGetNItems(ndims, dims);
117 
118  /* Count those that are NULL */
119  bitmap = ARR_NULLBITMAP(arr);
120  if (bitmap)
121  {
122  int bitmask = 1;
123 
124  for (i = 0; i < nitems; i++)
125  {
126  if ((*bitmap & bitmask) == 0)
127  count++;
128 
129  bitmask <<= 1;
130  if (bitmask == 0x100)
131  {
132  bitmap++;
133  bitmask = 1;
134  }
135  }
136  }
137 
138  *nargs = nitems;
139  *nulls = count;
140  }
141  else
142  {
143  /* Separate arguments, so just count 'em */
144  for (i = 0; i < PG_NARGS(); i++)
145  {
146  if (PG_ARGISNULL(i))
147  count++;
148  }
149 
150  *nargs = PG_NARGS();
151  *nulls = count;
152  }
153 
154  return true;
155 }
156 
157 /*
158  * num_nulls()
159  * Count the number of NULL arguments
160  */
161 Datum
163 {
164  int32 nargs,
165  nulls;
166 
167  if (!count_nulls(fcinfo, &nargs, &nulls))
168  PG_RETURN_NULL();
169 
170  PG_RETURN_INT32(nulls);
171 }
172 
173 /*
174  * num_nonnulls()
175  * Count the number of non-NULL arguments
176  */
177 Datum
179 {
180  int32 nargs,
181  nulls;
182 
183  if (!count_nulls(fcinfo, &nargs, &nulls))
184  PG_RETURN_NULL();
185 
186  PG_RETURN_INT32(nargs - nulls);
187 }
188 
189 
190 /*
191  * current_database()
192  * Expose the current database to the user
193  */
194 Datum
196 {
197  Name db;
198 
199  db = (Name) palloc(NAMEDATALEN);
200 
202  PG_RETURN_NAME(db);
203 }
204 
205 
206 /*
207  * current_query()
208  * Expose the current query to the user (useful in stored procedures)
209  * We might want to use ActivePortal->sourceText someday.
210  */
211 Datum
213 {
214  /* there is no easy way to access the more concise 'query_string' */
215  if (debug_query_string)
217  else
218  PG_RETURN_NULL();
219 }
220 
221 /* Function to find out which databases make use of a tablespace */
222 
223 Datum
225 {
226  Oid tablespaceOid = PG_GETARG_OID(0);
227  ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
228  char *location;
229  DIR *dirdesc;
230  struct dirent *de;
231 
233 
234  if (tablespaceOid == GLOBALTABLESPACE_OID)
235  {
237  (errmsg("global tablespace never has databases")));
238  /* return empty tuplestore */
239  return (Datum) 0;
240  }
241 
242  if (tablespaceOid == DEFAULTTABLESPACE_OID)
243  location = "base";
244  else
245  location = psprintf("pg_tblspc/%u/%s", tablespaceOid,
247 
248  dirdesc = AllocateDir(location);
249 
250  if (!dirdesc)
251  {
252  /* the only expected error is ENOENT */
253  if (errno != ENOENT)
254  ereport(ERROR,
256  errmsg("could not open directory \"%s\": %m",
257  location)));
259  (errmsg("%u is not a tablespace OID", tablespaceOid)));
260  /* return empty tuplestore */
261  return (Datum) 0;
262  }
263 
264  while ((de = ReadDir(dirdesc, location)) != NULL)
265  {
266  Oid datOid = atooid(de->d_name);
267  char *subdir;
268  bool isempty;
269  Datum values[1];
270  bool nulls[1];
271 
272  /* this test skips . and .., but is awfully weak */
273  if (!datOid)
274  continue;
275 
276  /* if database subdir is empty, don't report tablespace as used */
277 
278  subdir = psprintf("%s/%s", location, de->d_name);
279  isempty = directory_is_empty(subdir);
280  pfree(subdir);
281 
282  if (isempty)
283  continue; /* indeed, nothing in it */
284 
285  values[0] = ObjectIdGetDatum(datOid);
286  nulls[0] = false;
287 
288  tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
289  values, nulls);
290  }
291 
292  FreeDir(dirdesc);
293  return (Datum) 0;
294 }
295 
296 
297 /*
298  * pg_tablespace_location - get location for a tablespace
299  */
300 Datum
302 {
303  Oid tablespaceOid = PG_GETARG_OID(0);
304  char sourcepath[MAXPGPATH];
305  char targetpath[MAXPGPATH];
306  int rllen;
307  struct stat st;
308 
309  /*
310  * It's useful to apply this function to pg_class.reltablespace, wherein
311  * zero means "the database's default tablespace". So, rather than
312  * throwing an error for zero, we choose to assume that's what is meant.
313  */
314  if (tablespaceOid == InvalidOid)
315  tablespaceOid = MyDatabaseTableSpace;
316 
317  /*
318  * Return empty string for the cluster's default tablespaces
319  */
320  if (tablespaceOid == DEFAULTTABLESPACE_OID ||
321  tablespaceOid == GLOBALTABLESPACE_OID)
323 
324  /*
325  * Find the location of the tablespace by reading the symbolic link that
326  * is in pg_tblspc/<oid>.
327  */
328  snprintf(sourcepath, sizeof(sourcepath), "pg_tblspc/%u", tablespaceOid);
329 
330  /*
331  * Before reading the link, check if the source path is a link or a
332  * junction point. Note that a directory is possible for a tablespace
333  * created with allow_in_place_tablespaces enabled. If a directory is
334  * found, a relative path to the data directory is returned.
335  */
336  if (lstat(sourcepath, &st) < 0)
337  {
338  ereport(ERROR,
340  errmsg("could not stat file \"%s\": %m",
341  sourcepath)));
342  }
343 
344  if (!S_ISLNK(st.st_mode))
345  PG_RETURN_TEXT_P(cstring_to_text(sourcepath));
346 
347  /*
348  * In presence of a link or a junction point, return the path pointing to.
349  */
350  rllen = readlink(sourcepath, targetpath, sizeof(targetpath));
351  if (rllen < 0)
352  ereport(ERROR,
354  errmsg("could not read symbolic link \"%s\": %m",
355  sourcepath)));
356  if (rllen >= sizeof(targetpath))
357  ereport(ERROR,
358  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
359  errmsg("symbolic link \"%s\" target is too long",
360  sourcepath)));
361  targetpath[rllen] = '\0';
362 
363  PG_RETURN_TEXT_P(cstring_to_text(targetpath));
364 }
365 
366 /*
367  * pg_sleep - delay for N seconds
368  */
369 Datum
371 {
372  float8 secs = PG_GETARG_FLOAT8(0);
373  float8 endtime;
374 
375  /*
376  * We sleep using WaitLatch, to ensure that we'll wake up promptly if an
377  * important signal (such as SIGALRM or SIGINT) arrives. Because
378  * WaitLatch's upper limit of delay is INT_MAX milliseconds, and the user
379  * might ask for more than that, we sleep for at most 10 minutes and then
380  * loop.
381  *
382  * By computing the intended stop time initially, we avoid accumulation of
383  * extra delay across multiple sleeps. This also ensures we won't delay
384  * less than the specified time when WaitLatch is terminated early by a
385  * non-query-canceling signal such as SIGHUP.
386  */
387 #define GetNowFloat() ((float8) GetCurrentTimestamp() / 1000000.0)
388 
389  endtime = GetNowFloat() + secs;
390 
391  for (;;)
392  {
393  float8 delay;
394  long delay_ms;
395 
397 
398  delay = endtime - GetNowFloat();
399  if (delay >= 600.0)
400  delay_ms = 600000;
401  else if (delay > 0.0)
402  delay_ms = (long) ceil(delay * 1000.0);
403  else
404  break;
405 
406  (void) WaitLatch(MyLatch,
408  delay_ms,
409  WAIT_EVENT_PG_SLEEP);
411  }
412 
413  PG_RETURN_VOID();
414 }
415 
416 /* Function to return the list of grammar keywords */
417 Datum
419 {
420  FuncCallContext *funcctx;
421 
422  if (SRF_IS_FIRSTCALL())
423  {
424  MemoryContext oldcontext;
425  TupleDesc tupdesc;
426 
427  funcctx = SRF_FIRSTCALL_INIT();
428  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
429 
430  if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
431  elog(ERROR, "return type must be a row type");
432  funcctx->tuple_desc = tupdesc;
433  funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc);
434 
435  MemoryContextSwitchTo(oldcontext);
436  }
437 
438  funcctx = SRF_PERCALL_SETUP();
439 
440  if (funcctx->call_cntr < ScanKeywords.num_keywords)
441  {
442  char *values[5];
443  HeapTuple tuple;
444 
445  /* cast-away-const is ugly but alternatives aren't much better */
446  values[0] = unconstify(char *,
447  GetScanKeyword(funcctx->call_cntr,
448  &ScanKeywords));
449 
450  switch (ScanKeywordCategories[funcctx->call_cntr])
451  {
452  case UNRESERVED_KEYWORD:
453  values[1] = "U";
454  values[3] = _("unreserved");
455  break;
456  case COL_NAME_KEYWORD:
457  values[1] = "C";
458  values[3] = _("unreserved (cannot be function or type name)");
459  break;
461  values[1] = "T";
462  values[3] = _("reserved (can be function or type name)");
463  break;
464  case RESERVED_KEYWORD:
465  values[1] = "R";
466  values[3] = _("reserved");
467  break;
468  default: /* shouldn't be possible */
469  values[1] = NULL;
470  values[3] = NULL;
471  break;
472  }
473 
474  if (ScanKeywordBareLabel[funcctx->call_cntr])
475  {
476  values[2] = "true";
477  values[4] = _("can be bare label");
478  }
479  else
480  {
481  values[2] = "false";
482  values[4] = _("requires AS");
483  }
484 
485  tuple = BuildTupleFromCStrings(funcctx->attinmeta, values);
486 
487  SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
488  }
489 
490  SRF_RETURN_DONE(funcctx);
491 }
492 
493 
494 /* Function to return the list of catalog foreign key relationships */
495 Datum
497 {
498  FuncCallContext *funcctx;
499  FmgrInfo *arrayinp;
500 
501  if (SRF_IS_FIRSTCALL())
502  {
503  MemoryContext oldcontext;
504  TupleDesc tupdesc;
505 
506  funcctx = SRF_FIRSTCALL_INIT();
507  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
508 
509  if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
510  elog(ERROR, "return type must be a row type");
511  funcctx->tuple_desc = BlessTupleDesc(tupdesc);
512 
513  /*
514  * We use array_in to convert the C strings in sys_fk_relationships[]
515  * to text arrays. But we cannot use DirectFunctionCallN to call
516  * array_in, and it wouldn't be very efficient if we could. Fill an
517  * FmgrInfo to use for the call.
518  */
519  arrayinp = (FmgrInfo *) palloc(sizeof(FmgrInfo));
520  fmgr_info(F_ARRAY_IN, arrayinp);
521  funcctx->user_fctx = arrayinp;
522 
523  MemoryContextSwitchTo(oldcontext);
524  }
525 
526  funcctx = SRF_PERCALL_SETUP();
527  arrayinp = (FmgrInfo *) funcctx->user_fctx;
528 
529  if (funcctx->call_cntr < lengthof(sys_fk_relationships))
530  {
531  const SysFKRelationship *fkrel = &sys_fk_relationships[funcctx->call_cntr];
532  Datum values[6];
533  bool nulls[6];
534  HeapTuple tuple;
535 
536  memset(nulls, false, sizeof(nulls));
537 
538  values[0] = ObjectIdGetDatum(fkrel->fk_table);
539  values[1] = FunctionCall3(arrayinp,
540  CStringGetDatum(fkrel->fk_columns),
541  ObjectIdGetDatum(TEXTOID),
542  Int32GetDatum(-1));
543  values[2] = ObjectIdGetDatum(fkrel->pk_table);
544  values[3] = FunctionCall3(arrayinp,
545  CStringGetDatum(fkrel->pk_columns),
546  ObjectIdGetDatum(TEXTOID),
547  Int32GetDatum(-1));
548  values[4] = BoolGetDatum(fkrel->is_array);
549  values[5] = BoolGetDatum(fkrel->is_opt);
550 
551  tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
552 
553  SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
554  }
555 
556  SRF_RETURN_DONE(funcctx);
557 }
558 
559 
560 /*
561  * Return the type of the argument.
562  */
563 Datum
565 {
566  PG_RETURN_OID(get_fn_expr_argtype(fcinfo->flinfo, 0));
567 }
568 
569 
570 /*
571  * Implementation of the COLLATE FOR expression; returns the collation
572  * of the argument.
573  */
574 Datum
576 {
577  Oid typeid;
578  Oid collid;
579 
580  typeid = get_fn_expr_argtype(fcinfo->flinfo, 0);
581  if (!typeid)
582  PG_RETURN_NULL();
583  if (!type_is_collatable(typeid) && typeid != UNKNOWNOID)
584  ereport(ERROR,
585  (errcode(ERRCODE_DATATYPE_MISMATCH),
586  errmsg("collations are not supported by type %s",
587  format_type_be(typeid))));
588 
590  if (!collid)
591  PG_RETURN_NULL();
593 }
594 
595 
596 /*
597  * pg_relation_is_updatable - determine which update events the specified
598  * relation supports.
599  *
600  * This relies on relation_is_updatable() in rewriteHandler.c, which see
601  * for additional information.
602  */
603 Datum
605 {
606  Oid reloid = PG_GETARG_OID(0);
607  bool include_triggers = PG_GETARG_BOOL(1);
608 
609  PG_RETURN_INT32(relation_is_updatable(reloid, NIL, include_triggers, NULL));
610 }
611 
612 /*
613  * pg_column_is_updatable - determine whether a column is updatable
614  *
615  * This function encapsulates the decision about just what
616  * information_schema.columns.is_updatable actually means. It's not clear
617  * whether deletability of the column's relation should be required, so
618  * we want that decision in C code where we could change it without initdb.
619  */
620 Datum
622 {
623  Oid reloid = PG_GETARG_OID(0);
626  bool include_triggers = PG_GETARG_BOOL(2);
627  int events;
628 
629  /* System columns are never updatable */
630  if (attnum <= 0)
631  PG_RETURN_BOOL(false);
632 
633  events = relation_is_updatable(reloid, NIL, include_triggers,
634  bms_make_singleton(col));
635 
636  /* We require both updatability and deletability of the relation */
637 #define REQ_EVENTS ((1 << CMD_UPDATE) | (1 << CMD_DELETE))
638 
639  PG_RETURN_BOOL((events & REQ_EVENTS) == REQ_EVENTS);
640 }
641 
642 
643 /*
644  * pg_input_is_valid - test whether string is valid input for datatype.
645  *
646  * Returns true if OK, false if not.
647  *
648  * This will only work usefully if the datatype's input function has been
649  * updated to return "soft" errors via errsave/ereturn.
650  */
651 Datum
653 {
654  text *txt = PG_GETARG_TEXT_PP(0);
656  ErrorSaveContext escontext = {T_ErrorSaveContext};
657 
659  &escontext));
660 }
661 
662 /*
663  * pg_input_error_info - test whether string is valid input for datatype.
664  *
665  * Returns NULL if OK, else the primary message, detail message, hint message
666  * and sql error code from the error.
667  *
668  * This will only work usefully if the datatype's input function has been
669  * updated to return "soft" errors via errsave/ereturn.
670  */
671 Datum
673 {
674  text *txt = PG_GETARG_TEXT_PP(0);
676  ErrorSaveContext escontext = {T_ErrorSaveContext};
677  TupleDesc tupdesc;
678  Datum values[4];
679  bool isnull[4];
680 
681  if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
682  elog(ERROR, "return type must be a row type");
683 
684  /* Enable details_wanted */
685  escontext.details_wanted = true;
686 
687  if (pg_input_is_valid_common(fcinfo, txt, typname,
688  &escontext))
689  memset(isnull, true, sizeof(isnull));
690  else
691  {
692  char *sqlstate;
693 
694  Assert(escontext.error_occurred);
695  Assert(escontext.error_data != NULL);
696  Assert(escontext.error_data->message != NULL);
697 
698  memset(isnull, false, sizeof(isnull));
699 
700  values[0] = CStringGetTextDatum(escontext.error_data->message);
701 
702  if (escontext.error_data->detail != NULL)
703  values[1] = CStringGetTextDatum(escontext.error_data->detail);
704  else
705  isnull[1] = true;
706 
707  if (escontext.error_data->hint != NULL)
708  values[2] = CStringGetTextDatum(escontext.error_data->hint);
709  else
710  isnull[2] = true;
711 
712  sqlstate = unpack_sql_state(escontext.error_data->sqlerrcode);
713  values[3] = CStringGetTextDatum(sqlstate);
714  }
715 
716  return HeapTupleGetDatum(heap_form_tuple(tupdesc, values, isnull));
717 }
718 
719 /* Common subroutine for the above */
720 static bool
722  text *txt, text *typname,
723  ErrorSaveContext *escontext)
724 {
725  char *str = text_to_cstring(txt);
726  ValidIOData *my_extra;
727  Datum converted;
728 
729  /*
730  * We arrange to look up the needed I/O info just once per series of
731  * calls, assuming the data type doesn't change underneath us.
732  */
733  my_extra = (ValidIOData *) fcinfo->flinfo->fn_extra;
734  if (my_extra == NULL)
735  {
736  fcinfo->flinfo->fn_extra =
738  sizeof(ValidIOData));
739  my_extra = (ValidIOData *) fcinfo->flinfo->fn_extra;
740  my_extra->typoid = InvalidOid;
741  /* Detect whether typname argument is constant. */
742  my_extra->typname_constant = get_fn_expr_arg_stable(fcinfo->flinfo, 1);
743  }
744 
745  /*
746  * If the typname argument is constant, we only need to parse it the first
747  * time through.
748  */
749  if (my_extra->typoid == InvalidOid || !my_extra->typname_constant)
750  {
751  char *typnamestr = text_to_cstring(typname);
752  Oid typoid;
753 
754  /* Parse type-name argument to obtain type OID and encoded typmod. */
755  (void) parseTypeString(typnamestr, &typoid, &my_extra->typmod, NULL);
756 
757  /* Update type-specific info if typoid changed. */
758  if (my_extra->typoid != typoid)
759  {
760  getTypeInputInfo(typoid,
761  &my_extra->typiofunc,
762  &my_extra->typioparam);
763  fmgr_info_cxt(my_extra->typiofunc, &my_extra->inputproc,
764  fcinfo->flinfo->fn_mcxt);
765  my_extra->typoid = typoid;
766  }
767  }
768 
769  /* Now we can try to perform the conversion. */
770  return InputFunctionCallSafe(&my_extra->inputproc,
771  str,
772  my_extra->typioparam,
773  my_extra->typmod,
774  (Node *) escontext,
775  &converted);
776 }
777 
778 
779 /*
780  * Is character a valid identifier start?
781  * Must match scan.l's {ident_start} character class.
782  */
783 static bool
784 is_ident_start(unsigned char c)
785 {
786  /* Underscores and ASCII letters are OK */
787  if (c == '_')
788  return true;
789  if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
790  return true;
791  /* Any high-bit-set character is OK (might be part of a multibyte char) */
792  if (IS_HIGHBIT_SET(c))
793  return true;
794  return false;
795 }
796 
797 /*
798  * Is character a valid identifier continuation?
799  * Must match scan.l's {ident_cont} character class.
800  */
801 static bool
802 is_ident_cont(unsigned char c)
803 {
804  /* Can be digit or dollar sign ... */
805  if ((c >= '0' && c <= '9') || c == '$')
806  return true;
807  /* ... or an identifier start character */
808  return is_ident_start(c);
809 }
810 
811 /*
812  * parse_ident - parse a SQL qualified identifier into separate identifiers.
813  * When strict mode is active (second parameter), then any chars after
814  * the last identifier are disallowed.
815  */
816 Datum
818 {
819  text *qualname = PG_GETARG_TEXT_PP(0);
820  bool strict = PG_GETARG_BOOL(1);
821  char *qualname_str = text_to_cstring(qualname);
822  ArrayBuildState *astate = NULL;
823  char *nextp;
824  bool after_dot = false;
825 
826  /*
827  * The code below scribbles on qualname_str in some cases, so we should
828  * reconvert qualname if we need to show the original string in error
829  * messages.
830  */
831  nextp = qualname_str;
832 
833  /* skip leading whitespace */
834  while (scanner_isspace(*nextp))
835  nextp++;
836 
837  for (;;)
838  {
839  char *curname;
840  bool missing_ident = true;
841 
842  if (*nextp == '"')
843  {
844  char *endp;
845 
846  curname = nextp + 1;
847  for (;;)
848  {
849  endp = strchr(nextp + 1, '"');
850  if (endp == NULL)
851  ereport(ERROR,
852  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
853  errmsg("string is not a valid identifier: \"%s\"",
854  text_to_cstring(qualname)),
855  errdetail("String has unclosed double quotes.")));
856  if (endp[1] != '"')
857  break;
858  memmove(endp, endp + 1, strlen(endp));
859  nextp = endp;
860  }
861  nextp = endp + 1;
862  *endp = '\0';
863 
864  if (endp - curname == 0)
865  ereport(ERROR,
866  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
867  errmsg("string is not a valid identifier: \"%s\"",
868  text_to_cstring(qualname)),
869  errdetail("Quoted identifier must not be empty.")));
870 
871  astate = accumArrayResult(astate, CStringGetTextDatum(curname),
872  false, TEXTOID, CurrentMemoryContext);
873  missing_ident = false;
874  }
875  else if (is_ident_start((unsigned char) *nextp))
876  {
877  char *downname;
878  int len;
879  text *part;
880 
881  curname = nextp++;
882  while (is_ident_cont((unsigned char) *nextp))
883  nextp++;
884 
885  len = nextp - curname;
886 
887  /*
888  * We don't implicitly truncate identifiers. This is useful for
889  * allowing the user to check for specific parts of the identifier
890  * being too long. It's easy enough for the user to get the
891  * truncated names by casting our output to name[].
892  */
893  downname = downcase_identifier(curname, len, false, false);
894  part = cstring_to_text_with_len(downname, len);
895  astate = accumArrayResult(astate, PointerGetDatum(part), false,
896  TEXTOID, CurrentMemoryContext);
897  missing_ident = false;
898  }
899 
900  if (missing_ident)
901  {
902  /* Different error messages based on where we failed. */
903  if (*nextp == '.')
904  ereport(ERROR,
905  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
906  errmsg("string is not a valid identifier: \"%s\"",
907  text_to_cstring(qualname)),
908  errdetail("No valid identifier before \".\".")));
909  else if (after_dot)
910  ereport(ERROR,
911  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
912  errmsg("string is not a valid identifier: \"%s\"",
913  text_to_cstring(qualname)),
914  errdetail("No valid identifier after \".\".")));
915  else
916  ereport(ERROR,
917  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
918  errmsg("string is not a valid identifier: \"%s\"",
919  text_to_cstring(qualname))));
920  }
921 
922  while (scanner_isspace(*nextp))
923  nextp++;
924 
925  if (*nextp == '.')
926  {
927  after_dot = true;
928  nextp++;
929  while (scanner_isspace(*nextp))
930  nextp++;
931  }
932  else if (*nextp == '\0')
933  {
934  break;
935  }
936  else
937  {
938  if (strict)
939  ereport(ERROR,
940  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
941  errmsg("string is not a valid identifier: \"%s\"",
942  text_to_cstring(qualname))));
943  break;
944  }
945  }
946 
948 }
949 
950 /*
951  * pg_current_logfile
952  *
953  * Report current log file used by log collector by scanning current_logfiles.
954  */
955 Datum
957 {
958  FILE *fd;
959  char lbuffer[MAXPGPATH];
960  char *logfmt;
961 
962  /* The log format parameter is optional */
963  if (PG_NARGS() == 0 || PG_ARGISNULL(0))
964  logfmt = NULL;
965  else
966  {
967  logfmt = text_to_cstring(PG_GETARG_TEXT_PP(0));
968 
969  if (strcmp(logfmt, "stderr") != 0 &&
970  strcmp(logfmt, "csvlog") != 0 &&
971  strcmp(logfmt, "jsonlog") != 0)
972  ereport(ERROR,
973  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
974  errmsg("log format \"%s\" is not supported", logfmt),
975  errhint("The supported log formats are \"stderr\", \"csvlog\", and \"jsonlog\".")));
976  }
977 
979  if (fd == NULL)
980  {
981  if (errno != ENOENT)
982  ereport(ERROR,
984  errmsg("could not read file \"%s\": %m",
986  PG_RETURN_NULL();
987  }
988 
989 #ifdef WIN32
990  /* syslogger.c writes CRLF line endings on Windows */
991  _setmode(_fileno(fd), _O_TEXT);
992 #endif
993 
994  /*
995  * Read the file to gather current log filename(s) registered by the
996  * syslogger.
997  */
998  while (fgets(lbuffer, sizeof(lbuffer), fd) != NULL)
999  {
1000  char *log_format;
1001  char *log_filepath;
1002  char *nlpos;
1003 
1004  /* Extract log format and log file path from the line. */
1005  log_format = lbuffer;
1006  log_filepath = strchr(lbuffer, ' ');
1007  if (log_filepath == NULL)
1008  {
1009  /* Uh oh. No space found, so file content is corrupted. */
1010  elog(ERROR,
1011  "missing space character in \"%s\"", LOG_METAINFO_DATAFILE);
1012  break;
1013  }
1014 
1015  *log_filepath = '\0';
1016  log_filepath++;
1017  nlpos = strchr(log_filepath, '\n');
1018  if (nlpos == NULL)
1019  {
1020  /* Uh oh. No newline found, so file content is corrupted. */
1021  elog(ERROR,
1022  "missing newline character in \"%s\"", LOG_METAINFO_DATAFILE);
1023  break;
1024  }
1025  *nlpos = '\0';
1026 
1027  if (logfmt == NULL || strcmp(logfmt, log_format) == 0)
1028  {
1029  FreeFile(fd);
1030  PG_RETURN_TEXT_P(cstring_to_text(log_filepath));
1031  }
1032  }
1033 
1034  /* Close the current log filename file. */
1035  FreeFile(fd);
1036 
1037  PG_RETURN_NULL();
1038 }
1039 
1040 /*
1041  * Report current log file used by log collector (1 argument version)
1042  *
1043  * note: this wrapper is necessary to pass the sanity check in opr_sanity,
1044  * which checks that all built-in functions that share the implementing C
1045  * function take the same number of arguments
1046  */
1047 Datum
1049 {
1050  return pg_current_logfile(fcinfo);
1051 }
1052 
1053 /*
1054  * SQL wrapper around RelationGetReplicaIndex().
1055  */
1056 Datum
1058 {
1059  Oid reloid = PG_GETARG_OID(0);
1060  Oid idxoid;
1061  Relation rel;
1062 
1063  rel = table_open(reloid, AccessShareLock);
1064  idxoid = RelationGetReplicaIndex(rel);
1066 
1067  if (OidIsValid(idxoid))
1068  PG_RETURN_OID(idxoid);
1069  else
1070  PG_RETURN_NULL();
1071 }
1072 
1073 /*
1074  * Transition function for the ANY_VALUE aggregate
1075  */
1076 Datum
1078 {
1080 }
#define ARR_NDIM(a)
Definition: array.h:290
#define PG_GETARG_ARRAYTYPE_P(n)
Definition: array.h:263
#define ARR_NULLBITMAP(a)
Definition: array.h:300
#define ARR_DIMS(a)
Definition: array.h:294
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5332
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5402
int ArrayGetNItems(int ndim, const int *dims)
Definition: arrayutils.c:57
int16 AttrNumber
Definition: attnum.h:21
bool directory_is_empty(const char *path)
Definition: tablespace.c:859
Datum pg_typeof(PG_FUNCTION_ARGS)
Definition: misc.c:564
struct ValidIOData ValidIOData
Datum parse_ident(PG_FUNCTION_ARGS)
Definition: misc.c:817
static bool count_nulls(FunctionCallInfo fcinfo, int32 *nargs, int32 *nulls)
Definition: misc.c:76
Datum pg_tablespace_databases(PG_FUNCTION_ARGS)
Definition: misc.c:224
#define GetNowFloat()
static bool is_ident_cont(unsigned char c)
Definition: misc.c:802
#define REQ_EVENTS
Datum current_query(PG_FUNCTION_ARGS)
Definition: misc.c:212
Datum pg_get_catalog_foreign_keys(PG_FUNCTION_ARGS)
Definition: misc.c:496
static bool pg_input_is_valid_common(FunctionCallInfo fcinfo, text *txt, text *typname, ErrorSaveContext *escontext)
Definition: misc.c:721
Datum pg_input_error_info(PG_FUNCTION_ARGS)
Definition: misc.c:672
Datum pg_input_is_valid(PG_FUNCTION_ARGS)
Definition: misc.c:652
Datum any_value_transfn(PG_FUNCTION_ARGS)
Definition: misc.c:1077
Datum pg_sleep(PG_FUNCTION_ARGS)
Definition: misc.c:370
Datum pg_get_replica_identity_index(PG_FUNCTION_ARGS)
Definition: misc.c:1057
Datum pg_current_logfile(PG_FUNCTION_ARGS)
Definition: misc.c:956
Datum pg_get_keywords(PG_FUNCTION_ARGS)
Definition: misc.c:418
static bool is_ident_start(unsigned char c)
Definition: misc.c:784
Datum current_database(PG_FUNCTION_ARGS)
Definition: misc.c:195
Datum pg_column_is_updatable(PG_FUNCTION_ARGS)
Definition: misc.c:621
Datum pg_num_nulls(PG_FUNCTION_ARGS)
Definition: misc.c:162
Datum pg_current_logfile_1arg(PG_FUNCTION_ARGS)
Definition: misc.c:1048
Datum pg_tablespace_location(PG_FUNCTION_ARGS)
Definition: misc.c:301
Datum pg_relation_is_updatable(PG_FUNCTION_ARGS)
Definition: misc.c:604
Datum pg_collation_for(PG_FUNCTION_ARGS)
Definition: misc.c:575
Datum pg_num_nonnulls(PG_FUNCTION_ARGS)
Definition: misc.c:178
Bitmapset * bms_make_singleton(int x)
Definition: bitmapset.c:229
static Datum values[MAXATTR]
Definition: bootstrap.c:156
#define CStringGetTextDatum(s)
Definition: builtins.h:97
#define unconstify(underlying_type, expr)
Definition: c.h:1234
NameData * Name
Definition: c.h:733
#define IS_HIGHBIT_SET(ch)
Definition: c.h:1144
signed int int32
Definition: c.h:483
double float8
Definition: c.h:619
uint8 bits8
Definition: c.h:502
#define lengthof(array)
Definition: c.h:777
#define OidIsValid(objectId)
Definition: c.h:764
Oid collid
const uint8 ScanKeywordCategories[SCANKEYWORDS_NUM_KEYWORDS]
Definition: keywords.c:29
const bool ScanKeywordBareLabel[SCANKEYWORDS_NUM_KEYWORDS]
Definition: keywords.c:42
char * get_database_name(Oid dbid)
Definition: dbcommands.c:3089
int errcode_for_file_access(void)
Definition: elog.c:883
int errdetail(const char *fmt,...)
Definition: elog.c:1208
int errhint(const char *fmt,...)
Definition: elog.c:1322
char * unpack_sql_state(int sql_state)
Definition: elog.c:3130
int errcode(int sqlerrcode)
Definition: elog.c:860
int errmsg(const char *fmt,...)
Definition: elog.c:1075
#define _(x)
Definition: elog.c:91
#define WARNING
Definition: elog.h:36
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2070
HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
Definition: execTuples.c:2134
AttInMetadata * TupleDescGetAttInMetadata(TupleDesc tupdesc)
Definition: execTuples.c:2085
struct dirent * ReadDir(DIR *dir, const char *dirname)
Definition: fd.c:2909
int FreeDir(DIR *dir)
Definition: fd.c:2961
FILE * AllocateFile(const char *name, const char *mode)
Definition: fd.c:2583
int FreeFile(FILE *file)
Definition: fd.c:2781
DIR * AllocateDir(const char *dirname)
Definition: fd.c:2843
bool get_fn_expr_arg_stable(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1975
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:127
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:137
bool InputFunctionCallSafe(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod, fmNodePtr escontext, Datum *result)
Definition: fmgr.c:1585
bool get_fn_expr_variadic(FmgrInfo *flinfo)
Definition: fmgr.c:2044
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1910
#define PG_RETURN_VOID()
Definition: fmgr.h:349
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define PG_GETARG_FLOAT8(n)
Definition: fmgr.h:282
#define PG_ARGISNULL(n)
Definition: fmgr.h:209
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:268
#define PG_NARGS()
Definition: fmgr.h:203
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:372
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
#define PG_RETURN_NAME(x)
Definition: fmgr.h:363
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:274
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
#define PG_GET_COLLATION()
Definition: fmgr.h:198
#define FunctionCall3(flinfo, arg1, arg2, arg3)
Definition: fmgr.h:664
#define PG_RETURN_OID(x)
Definition: fmgr.h:360
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
#define PG_GETARG_INT16(n)
Definition: fmgr.h:271
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
void InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags)
Definition: funcapi.c:76
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:276
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:304
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:308
@ TYPEFUNC_COMPOSITE
Definition: funcapi.h:149
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:310
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:306
static Datum HeapTupleGetDatum(const HeapTupleData *tuple)
Definition: funcapi.h:230
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:328
#define MAT_SRF_USE_EXPECTED_DESC
Definition: funcapi.h:296
Oid MyDatabaseTableSpace
Definition: globals.c:92
struct Latch * MyLatch
Definition: globals.c:59
Oid MyDatabaseId
Definition: globals.c:90
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1117
#define nitems(x)
Definition: indent.h:31
int i
Definition: isn.c:73
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
PGDLLIMPORT const ScanKeywordList ScanKeywords
#define COL_NAME_KEYWORD
Definition: keywords.h:21
#define UNRESERVED_KEYWORD
Definition: keywords.h:20
#define TYPE_FUNC_NAME_KEYWORD
Definition: keywords.h:22
#define RESERVED_KEYWORD
Definition: keywords.h:23
static const char * GetScanKeyword(int n, const ScanKeywordList *keywords)
Definition: kwlookup.h:39
void ResetLatch(Latch *latch)
Definition: latch.c:725
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
Definition: latch.c:518
#define WL_TIMEOUT
Definition: latch.h:130
#define WL_EXIT_ON_PM_DEATH
Definition: latch.h:132
#define WL_LATCH_SET
Definition: latch.h:127
Assert(fmt[strlen(fmt) - 1] !='\n')
#define AccessShareLock
Definition: lockdefs.h:36
void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
Definition: lsyscache.c:2829
bool type_is_collatable(Oid typid)
Definition: lsyscache.c:3036
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2787
void pfree(void *pointer)
Definition: mcxt.c:1431
MemoryContext CurrentMemoryContext
Definition: mcxt.c:135
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1034
void * palloc(Size size)
Definition: mcxt.c:1201
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
void namestrcpy(Name name, const char *str)
Definition: name.c:233
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
bool parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, Node *escontext)
Definition: parse_type.c:785
int16 attnum
Definition: pg_attribute.h:74
#define NAMEDATALEN
#define MAXPGPATH
const void size_t len
#define NIL
Definition: pg_list.h:68
NameData typname
Definition: pg_type.h:41
#define snprintf
Definition: port.h:238
const char * debug_query_string
Definition: postgres.c:86
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
static Datum BoolGetDatum(bool X)
Definition: postgres.h:102
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
#define atooid(x)
Definition: postgres_ext.h:42
char * c
static int fd(const char *x, int i)
Definition: preproc-init.c:105
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
Oid RelationGetReplicaIndex(Relation relation)
Definition: relcache.c:4986
#define TABLESPACE_VERSION_DIRECTORY
Definition: relpath.h:33
int relation_is_updatable(Oid reloid, List *outer_reloids, bool include_triggers, Bitmapset *include_cols)
char * generate_collation_name(Oid collid)
Definition: ruleutils.c:12487
bool scanner_isspace(char ch)
Definition: scansup.c:117
char * downcase_identifier(const char *ident, int len, bool warn, bool truncate)
Definition: scansup.c:46
Definition: dirent.c:26
int sqlerrcode
Definition: elog.h:438
char * detail
Definition: elog.h:440
char * message
Definition: elog.h:439
char * hint
Definition: elog.h:442
bool details_wanted
Definition: miscnodes.h:47
ErrorData * error_data
Definition: miscnodes.h:48
bool error_occurred
Definition: miscnodes.h:46
Definition: fmgr.h:57
void * fn_extra
Definition: fmgr.h:64
MemoryContext fn_mcxt
Definition: fmgr.h:65
void * user_fctx
Definition: funcapi.h:82
uint64 call_cntr
Definition: funcapi.h:65
AttInMetadata * attinmeta
Definition: funcapi.h:91
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
TupleDesc tuple_desc
Definition: funcapi.h:112
FmgrInfo * flinfo
Definition: fmgr.h:87
Definition: nodes.h:129
TupleDesc setDesc
Definition: execnodes.h:340
Tuplestorestate * setResult
Definition: execnodes.h:339
int num_keywords
Definition: kwlookup.h:30
int32 typmod
Definition: misc.c:57
Oid typoid
Definition: misc.c:56
bool typname_constant
Definition: misc.c:58
FmgrInfo inputproc
Definition: misc.c:61
Oid typiofunc
Definition: misc.c:59
Oid typioparam
Definition: misc.c:60
Definition: dirent.h:10
Definition: c.h:730
unsigned short st_mode
Definition: win32_port.h:268
Definition: c.h:676
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27
#define LOG_METAINFO_DATAFILE
Definition: syslogger.h:100
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc, const Datum *values, const bool *isnull)
Definition: tuplestore.c:750
char * text_to_cstring(const text *t)
Definition: varlena.c:217
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:196
text * cstring_to_text(const char *s)
Definition: varlena.c:184
#define lstat(path, sb)
Definition: win32_port.h:285
#define S_ISLNK(m)
Definition: win32_port.h:344
#define readlink(path, buf, size)
Definition: win32_port.h:236