Branch data     Line data    Source code

       1                 :             : /*-------------------------------------------------------------------------
       2                 :             :  *
       3                 :             :  * kwlookup.c
       4                 :             :  *    Key word lookup for PostgreSQL
       5                 :             :  *
       6                 :             :  *
       7                 :             :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       8                 :             :  * Portions Copyright (c) 1994, Regents of the University of California
       9                 :             :  *
      10                 :             :  *
      11                 :             :  * IDENTIFICATION
      12                 :             :  *    src/common/kwlookup.c
      13                 :             :  *
      14                 :             :  *-------------------------------------------------------------------------
      15                 :             :  */
      16                 :             : #include "c.h"
      17                 :             : 
      18                 :             : #include "common/kwlookup.h"
      19                 :             : 
      20                 :             : 
      21                 :             : /*
      22                 :             :  * ScanKeywordLookup - see if a given word is a keyword
      23                 :             :  *
      24                 :             :  * The list of keywords to be matched against is passed as a ScanKeywordList.
      25                 :             :  *
      26                 :             :  * Returns the keyword number (0..N-1) of the keyword, or -1 if no match.
      27                 :             :  * Callers typically use the keyword number to index into information
      28                 :             :  * arrays, but that is no concern of this code.
      29                 :             :  *
      30                 :             :  * The match is done case-insensitively.  Note that we deliberately use a
      31                 :             :  * dumbed-down case conversion that will only translate 'A'-'Z' into 'a'-'z',
      32                 :             :  * even if we are in a locale where tolower() would produce more or different
      33                 :             :  * translations.  This is to conform to the SQL99 spec, which says that
      34                 :             :  * keywords are to be matched in this way even though non-keyword identifiers
      35                 :             :  * receive a different case-normalization mapping.
      36                 :             :  */
      37                 :             : int
      38                 :     9416830 : ScanKeywordLookup(const char *str,
      39                 :             :                   const ScanKeywordList *keywords)
      40                 :             : {
      41                 :             :     size_t      len;
      42                 :             :     int         h;
      43                 :             :     const char *kw;
      44                 :             : 
      45                 :             :     /*
      46                 :             :      * Reject immediately if too long to be any keyword.  This saves useless
      47                 :             :      * hashing and downcasing work on long strings.
      48                 :             :      */
      49                 :     9416830 :     len = strlen(str);
      50         [ +  + ]:     9416830 :     if (len > keywords->max_kw_len)
      51                 :      387421 :         return -1;
      52                 :             : 
      53                 :             :     /*
      54                 :             :      * Compute the hash function.  We assume it was generated to produce
      55                 :             :      * case-insensitive results.  Since it's a perfect hash, we need only
      56                 :             :      * match to the specific keyword it identifies.
      57                 :             :      */
      58                 :     9029409 :     h = keywords->hash(str, len);
      59                 :             : 
      60                 :             :     /* An out-of-range result implies no match */
      61   [ +  +  +  + ]:     9029409 :     if (h < 0 || h >= keywords->num_keywords)
      62                 :     4341301 :         return -1;
      63                 :             : 
      64                 :             :     /*
      65                 :             :      * Compare character-by-character to see if we have a match, applying an
      66                 :             :      * ASCII-only downcasing to the input characters.  We must not use
      67                 :             :      * tolower() since it may produce the wrong translation in some locales
      68                 :             :      * (eg, Turkish).
      69                 :             :      */
      70                 :     4688108 :     kw = GetScanKeyword(h, keywords);
      71         [ +  + ]:    20785086 :     while (*str != '\0')
      72                 :             :     {
      73                 :    17223759 :         char        ch = *str++;
      74                 :             : 
      75   [ +  +  +  + ]:    17223759 :         if (ch >= 'A' && ch <= 'Z')
      76                 :    11286527 :             ch += 'a' - 'A';
      77         [ +  + ]:    17223759 :         if (ch != *kw++)
      78                 :     1126781 :             return -1;
      79                 :             :     }
      80         [ +  + ]:     3561327 :     if (*kw != '\0')
      81                 :         689 :         return -1;
      82                 :             : 
      83                 :             :     /* Success! */
      84                 :     3560638 :     return h;
      85                 :             : }