LCOV - code coverage report
Current view: top level - src/backend/utils/adt - misc.c (source / functions) Hit Total Coverage
Test: PostgreSQL 19devel Lines: 288 368 78.3 %
Date: 2025-10-24 12:17:48 Functions: 24 26 92.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.16