LCOV - code coverage report
Current view: top level - src/backend/utils/adt - name.c (source / functions) Hit Total Coverage
Test: PostgreSQL 15beta1 Lines: 105 113 92.9 %
Date: 2022-05-18 04:09:35 Functions: 20 20 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * name.c
       4             :  *    Functions for the built-in type "name".
       5             :  *
       6             :  * name replaces char16 and is carefully implemented so that it
       7             :  * is a string of physical length NAMEDATALEN.
       8             :  * DO NOT use hard-coded constants anywhere
       9             :  * always use NAMEDATALEN as the symbolic constant!   - jolly 8/21/95
      10             :  *
      11             :  *
      12             :  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
      13             :  * Portions Copyright (c) 1994, Regents of the University of California
      14             :  *
      15             :  *
      16             :  * IDENTIFICATION
      17             :  *    src/backend/utils/adt/name.c
      18             :  *
      19             :  *-------------------------------------------------------------------------
      20             :  */
      21             : #include "postgres.h"
      22             : 
      23             : #include "catalog/namespace.h"
      24             : #include "catalog/pg_collation.h"
      25             : #include "catalog/pg_type.h"
      26             : #include "libpq/pqformat.h"
      27             : #include "mb/pg_wchar.h"
      28             : #include "miscadmin.h"
      29             : #include "utils/array.h"
      30             : #include "utils/builtins.h"
      31             : #include "utils/lsyscache.h"
      32             : #include "utils/varlena.h"
      33             : 
      34             : 
      35             : /*****************************************************************************
      36             :  *   USER I/O ROUTINES (none)                                                *
      37             :  *****************************************************************************/
      38             : 
      39             : 
      40             : /*
      41             :  *      namein  - converts "..." to internal representation
      42             :  *
      43             :  *      Note:
      44             :  *              [Old] Currently if strlen(s) < NAMEDATALEN, the extra chars are nulls
      45             :  *              Now, always NULL terminated
      46             :  */
      47             : Datum
      48     3055624 : namein(PG_FUNCTION_ARGS)
      49             : {
      50     3055624 :     char       *s = PG_GETARG_CSTRING(0);
      51             :     Name        result;
      52             :     int         len;
      53             : 
      54     3055624 :     len = strlen(s);
      55             : 
      56             :     /* Truncate oversize input */
      57     3055624 :     if (len >= NAMEDATALEN)
      58          54 :         len = pg_mbcliplen(s, len, NAMEDATALEN - 1);
      59             : 
      60             :     /* We use palloc0 here to ensure result is zero-padded */
      61     3055624 :     result = (Name) palloc0(NAMEDATALEN);
      62     3055624 :     memcpy(NameStr(*result), s, len);
      63             : 
      64     3055624 :     PG_RETURN_NAME(result);
      65             : }
      66             : 
      67             : /*
      68             :  *      nameout - converts internal representation to "..."
      69             :  */
      70             : Datum
      71     1526450 : nameout(PG_FUNCTION_ARGS)
      72             : {
      73     1526450 :     Name        s = PG_GETARG_NAME(0);
      74             : 
      75     1526450 :     PG_RETURN_CSTRING(pstrdup(NameStr(*s)));
      76             : }
      77             : 
      78             : /*
      79             :  *      namerecv            - converts external binary format to name
      80             :  */
      81             : Datum
      82           6 : namerecv(PG_FUNCTION_ARGS)
      83             : {
      84           6 :     StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
      85             :     Name        result;
      86             :     char       *str;
      87             :     int         nbytes;
      88             : 
      89           6 :     str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
      90           6 :     if (nbytes >= NAMEDATALEN)
      91           0 :         ereport(ERROR,
      92             :                 (errcode(ERRCODE_NAME_TOO_LONG),
      93             :                  errmsg("identifier too long"),
      94             :                  errdetail("Identifier must be less than %d characters.",
      95             :                            NAMEDATALEN)));
      96           6 :     result = (NameData *) palloc0(NAMEDATALEN);
      97           6 :     memcpy(result, str, nbytes);
      98           6 :     pfree(str);
      99           6 :     PG_RETURN_NAME(result);
     100             : }
     101             : 
     102             : /*
     103             :  *      namesend            - converts name to binary format
     104             :  */
     105             : Datum
     106           6 : namesend(PG_FUNCTION_ARGS)
     107             : {
     108           6 :     Name        s = PG_GETARG_NAME(0);
     109             :     StringInfoData buf;
     110             : 
     111           6 :     pq_begintypsend(&buf);
     112           6 :     pq_sendtext(&buf, NameStr(*s), strlen(NameStr(*s)));
     113           6 :     PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
     114             : }
     115             : 
     116             : 
     117             : /*****************************************************************************
     118             :  *   COMPARISON/SORTING ROUTINES                                             *
     119             :  *****************************************************************************/
     120             : 
     121             : /*
     122             :  *      nameeq  - returns 1 iff arguments are equal
     123             :  *      namene  - returns 1 iff arguments are not equal
     124             :  *      namelt  - returns 1 iff a < b
     125             :  *      namele  - returns 1 iff a <= b
     126             :  *      namegt  - returns 1 iff a > b
     127             :  *      namege  - returns 1 iff a >= b
     128             :  *
     129             :  * Note that the use of strncmp with NAMEDATALEN limit is mostly historical;
     130             :  * strcmp would do as well, because we do not allow NAME values that don't
     131             :  * have a '\0' terminator.  Whatever might be past the terminator is not
     132             :  * considered relevant to comparisons.
     133             :  */
     134             : static int
     135    89279806 : namecmp(Name arg1, Name arg2, Oid collid)
     136             : {
     137             :     /* Fast path for common case used in system catalogs */
     138    89279806 :     if (collid == C_COLLATION_OID)
     139    89279806 :         return strncmp(NameStr(*arg1), NameStr(*arg2), NAMEDATALEN);
     140             : 
     141             :     /* Else rely on the varstr infrastructure */
     142           0 :     return varstr_cmp(NameStr(*arg1), strlen(NameStr(*arg1)),
     143           0 :                       NameStr(*arg2), strlen(NameStr(*arg2)),
     144             :                       collid);
     145             : }
     146             : 
     147             : Datum
     148    61270130 : nameeq(PG_FUNCTION_ARGS)
     149             : {
     150    61270130 :     Name        arg1 = PG_GETARG_NAME(0);
     151    61270130 :     Name        arg2 = PG_GETARG_NAME(1);
     152             : 
     153    61270130 :     PG_RETURN_BOOL(namecmp(arg1, arg2, PG_GET_COLLATION()) == 0);
     154             : }
     155             : 
     156             : Datum
     157       21620 : namene(PG_FUNCTION_ARGS)
     158             : {
     159       21620 :     Name        arg1 = PG_GETARG_NAME(0);
     160       21620 :     Name        arg2 = PG_GETARG_NAME(1);
     161             : 
     162       21620 :     PG_RETURN_BOOL(namecmp(arg1, arg2, PG_GET_COLLATION()) != 0);
     163             : }
     164             : 
     165             : Datum
     166       90554 : namelt(PG_FUNCTION_ARGS)
     167             : {
     168       90554 :     Name        arg1 = PG_GETARG_NAME(0);
     169       90554 :     Name        arg2 = PG_GETARG_NAME(1);
     170             : 
     171       90554 :     PG_RETURN_BOOL(namecmp(arg1, arg2, PG_GET_COLLATION()) < 0);
     172             : }
     173             : 
     174             : Datum
     175       11460 : namele(PG_FUNCTION_ARGS)
     176             : {
     177       11460 :     Name        arg1 = PG_GETARG_NAME(0);
     178       11460 :     Name        arg2 = PG_GETARG_NAME(1);
     179             : 
     180       11460 :     PG_RETURN_BOOL(namecmp(arg1, arg2, PG_GET_COLLATION()) <= 0);
     181             : }
     182             : 
     183             : Datum
     184        2764 : namegt(PG_FUNCTION_ARGS)
     185             : {
     186        2764 :     Name        arg1 = PG_GETARG_NAME(0);
     187        2764 :     Name        arg2 = PG_GETARG_NAME(1);
     188             : 
     189        2764 :     PG_RETURN_BOOL(namecmp(arg1, arg2, PG_GET_COLLATION()) > 0);
     190             : }
     191             : 
     192             : Datum
     193       14280 : namege(PG_FUNCTION_ARGS)
     194             : {
     195       14280 :     Name        arg1 = PG_GETARG_NAME(0);
     196       14280 :     Name        arg2 = PG_GETARG_NAME(1);
     197             : 
     198       14280 :     PG_RETURN_BOOL(namecmp(arg1, arg2, PG_GET_COLLATION()) >= 0);
     199             : }
     200             : 
     201             : Datum
     202    27868998 : btnamecmp(PG_FUNCTION_ARGS)
     203             : {
     204    27868998 :     Name        arg1 = PG_GETARG_NAME(0);
     205    27868998 :     Name        arg2 = PG_GETARG_NAME(1);
     206             : 
     207    27868998 :     PG_RETURN_INT32(namecmp(arg1, arg2, PG_GET_COLLATION()));
     208             : }
     209             : 
     210             : Datum
     211       69974 : btnamesortsupport(PG_FUNCTION_ARGS)
     212             : {
     213       69974 :     SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
     214       69974 :     Oid         collid = ssup->ssup_collation;
     215             :     MemoryContext oldcontext;
     216             : 
     217       69974 :     oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
     218             : 
     219             :     /* Use generic string SortSupport */
     220       69974 :     varstr_sortsupport(ssup, NAMEOID, collid);
     221             : 
     222       69974 :     MemoryContextSwitchTo(oldcontext);
     223             : 
     224       69974 :     PG_RETURN_VOID();
     225             : }
     226             : 
     227             : 
     228             : /*****************************************************************************
     229             :  *   MISCELLANEOUS PUBLIC ROUTINES                                           *
     230             :  *****************************************************************************/
     231             : 
     232             : void
     233     8391292 : namestrcpy(Name name, const char *str)
     234             : {
     235             :     /* NB: We need to zero-pad the destination. */
     236     8391292 :     strncpy(NameStr(*name), str, NAMEDATALEN);
     237     8391292 :     NameStr(*name)[NAMEDATALEN - 1] = '\0';
     238     8391292 : }
     239             : 
     240             : /*
     241             :  * Compare a NAME to a C string
     242             :  *
     243             :  * Assumes C collation always; be careful when using this for
     244             :  * anything but equality checks!
     245             :  */
     246             : int
     247    10308744 : namestrcmp(Name name, const char *str)
     248             : {
     249    10308744 :     if (!name && !str)
     250           0 :         return 0;
     251    10308744 :     if (!name)
     252           0 :         return -1;              /* NULL < anything */
     253    10308744 :     if (!str)
     254           0 :         return 1;               /* NULL < anything */
     255    10308744 :     return strncmp(NameStr(*name), str, NAMEDATALEN);
     256             : }
     257             : 
     258             : 
     259             : /*
     260             :  * SQL-functions CURRENT_USER, SESSION_USER
     261             :  */
     262             : Datum
     263       15300 : current_user(PG_FUNCTION_ARGS)
     264             : {
     265       15300 :     PG_RETURN_DATUM(DirectFunctionCall1(namein, CStringGetDatum(GetUserNameFromId(GetUserId(), false))));
     266             : }
     267             : 
     268             : Datum
     269          68 : session_user(PG_FUNCTION_ARGS)
     270             : {
     271          68 :     PG_RETURN_DATUM(DirectFunctionCall1(namein, CStringGetDatum(GetUserNameFromId(GetSessionUserId(), false))));
     272             : }
     273             : 
     274             : 
     275             : /*
     276             :  * SQL-functions CURRENT_SCHEMA, CURRENT_SCHEMAS
     277             :  */
     278             : Datum
     279          32 : current_schema(PG_FUNCTION_ARGS)
     280             : {
     281          32 :     List       *search_path = fetch_search_path(false);
     282             :     char       *nspname;
     283             : 
     284          32 :     if (search_path == NIL)
     285           6 :         PG_RETURN_NULL();
     286          26 :     nspname = get_namespace_name(linitial_oid(search_path));
     287          26 :     list_free(search_path);
     288          26 :     if (!nspname)
     289           0 :         PG_RETURN_NULL();       /* recently-deleted namespace? */
     290          26 :     PG_RETURN_DATUM(DirectFunctionCall1(namein, CStringGetDatum(nspname)));
     291             : }
     292             : 
     293             : Datum
     294         376 : current_schemas(PG_FUNCTION_ARGS)
     295             : {
     296         376 :     List       *search_path = fetch_search_path(PG_GETARG_BOOL(0));
     297             :     ListCell   *l;
     298             :     Datum      *names;
     299             :     int         i;
     300             :     ArrayType  *array;
     301             : 
     302         376 :     names = (Datum *) palloc(list_length(search_path) * sizeof(Datum));
     303         376 :     i = 0;
     304         688 :     foreach(l, search_path)
     305             :     {
     306             :         char       *nspname;
     307             : 
     308         312 :         nspname = get_namespace_name(lfirst_oid(l));
     309         312 :         if (nspname)            /* watch out for deleted namespace */
     310             :         {
     311         312 :             names[i] = DirectFunctionCall1(namein, CStringGetDatum(nspname));
     312         312 :             i++;
     313             :         }
     314             :     }
     315         376 :     list_free(search_path);
     316             : 
     317         376 :     array = construct_array(names, i,
     318             :                             NAMEOID,
     319             :                             NAMEDATALEN,    /* sizeof(Name) */
     320             :                             false,  /* Name is not by-val */
     321             :                             TYPALIGN_CHAR); /* alignment of Name */
     322             : 
     323         376 :     PG_RETURN_POINTER(array);
     324             : }
     325             : 
     326             : /*
     327             :  * SQL-function nameconcatoid(name, oid) returns name
     328             :  *
     329             :  * This is used in the information_schema to produce specific_name columns,
     330             :  * which are supposed to be unique per schema.  We achieve that (in an ugly
     331             :  * way) by appending the object's OID.  The result is the same as
     332             :  *      ($1::text || '_' || $2::text)::name
     333             :  * except that, if it would not fit in NAMEDATALEN, we make it do so by
     334             :  * truncating the name input (not the oid).
     335             :  */
     336             : Datum
     337       34120 : nameconcatoid(PG_FUNCTION_ARGS)
     338             : {
     339       34120 :     Name        nam = PG_GETARG_NAME(0);
     340       34120 :     Oid         oid = PG_GETARG_OID(1);
     341             :     Name        result;
     342             :     char        suffix[20];
     343             :     int         suflen;
     344             :     int         namlen;
     345             : 
     346       34120 :     suflen = snprintf(suffix, sizeof(suffix), "_%u", oid);
     347       34120 :     namlen = strlen(NameStr(*nam));
     348             : 
     349             :     /* Truncate oversize input by truncating name part, not suffix */
     350       34120 :     if (namlen + suflen >= NAMEDATALEN)
     351           0 :         namlen = pg_mbcliplen(NameStr(*nam), namlen, NAMEDATALEN - 1 - suflen);
     352             : 
     353             :     /* We use palloc0 here to ensure result is zero-padded */
     354       34120 :     result = (Name) palloc0(NAMEDATALEN);
     355       34120 :     memcpy(NameStr(*result), NameStr(*nam), namlen);
     356       34120 :     memcpy(NameStr(*result) + namlen, suffix, suflen);
     357             : 
     358       34120 :     PG_RETURN_NAME(result);
     359             : }

Generated by: LCOV version 1.14