src/backend/parser/keywords.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * keywords.c
   4  *        lexical token lookup for key words in PostgreSQL
   5  *
   6  * NB: This file is also used by pg_dump.
   7  *
   8  *
   9  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
  10  * Portions Copyright (c) 1994, Regents of the University of California
  11  *
  12  *
  13  * IDENTIFICATION
  14  *        $PostgreSQL$
  15  *
  16  *-------------------------------------------------------------------------
  17  */
  18
  19 /* Use c.h so that this file can be built in either frontend or backend */
  20 #include "c.h"
  21
  22 #include <ctype.h>
  23
  24 /*
  25  * This macro definition overrides the YYSTYPE union definition in gram.h.
  26  * We don't need that struct in this file, and including the real definition
  27  * would require sucking in some backend-only include files.
  28  */
  29 #define YYSTYPE int
  30
  31 #include "parser/keywords.h"
  32 #ifndef ECPG_COMPILE
  33 #include "parser/gram.h"
  34 #else
  35 #include "preproc.h"
  36 #endif
  37
  38 /*
  39  * List of keyword (name, token-value, category) entries.
  40  *
  41  * !!WARNING!!: This list must be sorted by ASCII name, because binary
  42  *               search is used to locate entries.
  43  */
  44 const ScanKeyword ScanKeywords[] = {
  45         /* name, value, category */
  46         {"abort", ABORT_P, UNRESERVED_KEYWORD},
  47         {"absolute", ABSOLUTE_P, UNRESERVED_KEYWORD},
  48         {"access", ACCESS, UNRESERVED_KEYWORD},
  49         {"action", ACTION, UNRESERVED_KEYWORD},
  50         {"add", ADD_P, UNRESERVED_KEYWORD},
  51         {"admin", ADMIN, UNRESERVED_KEYWORD},
  52         {"after", AFTER, UNRESERVED_KEYWORD},
  53         {"aggregate", AGGREGATE, UNRESERVED_KEYWORD},
  54         {"all", ALL, RESERVED_KEYWORD},
  55         {"also", ALSO, UNRESERVED_KEYWORD},
  56         {"alter", ALTER, UNRESERVED_KEYWORD},
  57         {"always", ALWAYS, UNRESERVED_KEYWORD},
  58         {"analyse", ANALYSE, RESERVED_KEYWORD},         /* British spelling */
  59         {"analyze", ANALYZE, RESERVED_KEYWORD},
  60         {"and", AND, RESERVED_KEYWORD},
  61         {"any", ANY, RESERVED_KEYWORD},
  62         {"array", ARRAY, RESERVED_KEYWORD},
  63         {"as", AS, RESERVED_KEYWORD},
  64         {"asc", ASC, RESERVED_KEYWORD},
  65         {"assertion", ASSERTION, UNRESERVED_KEYWORD},
  66         {"assignment", ASSIGNMENT, UNRESERVED_KEYWORD},
  67         {"asymmetric", ASYMMETRIC, RESERVED_KEYWORD},
  68         {"at", AT, UNRESERVED_KEYWORD},
  69         {"authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD},
  70         {"backward", BACKWARD, UNRESERVED_KEYWORD},
  71         {"before", BEFORE, UNRESERVED_KEYWORD},
  72         {"begin", BEGIN_P, UNRESERVED_KEYWORD},
  73         {"between", BETWEEN, TYPE_FUNC_NAME_KEYWORD},
  74         {"bigint", BIGINT, COL_NAME_KEYWORD},
  75         {"binary", BINARY, TYPE_FUNC_NAME_KEYWORD},
  76         {"bit", BIT, COL_NAME_KEYWORD},
  77         {"boolean", BOOLEAN_P, COL_NAME_KEYWORD},
  78         {"both", BOTH, RESERVED_KEYWORD},
  79         {"by", BY, UNRESERVED_KEYWORD},
  80         {"cache", CACHE, UNRESERVED_KEYWORD},
  81         {"called", CALLED, UNRESERVED_KEYWORD},
  82         {"cascade", CASCADE, UNRESERVED_KEYWORD},
  83         {"cascaded", CASCADED, UNRESERVED_KEYWORD},
  84         {"case", CASE, RESERVED_KEYWORD},
  85         {"cast", CAST, RESERVED_KEYWORD},
  86         {"chain", CHAIN, UNRESERVED_KEYWORD},
  87         {"char", CHAR_P, COL_NAME_KEYWORD},
  88         {"character", CHARACTER, COL_NAME_KEYWORD},
  89         {"characteristics", CHARACTERISTICS, UNRESERVED_KEYWORD},
  90         {"check", CHECK, RESERVED_KEYWORD},
  91         {"checkpoint", CHECKPOINT, UNRESERVED_KEYWORD},
  92         {"class", CLASS, UNRESERVED_KEYWORD},
  93         {"close", CLOSE, UNRESERVED_KEYWORD},
  94         {"cluster", CLUSTER, UNRESERVED_KEYWORD},
  95         {"coalesce", COALESCE, COL_NAME_KEYWORD},
  96         {"collate", COLLATE, RESERVED_KEYWORD},
  97         {"column", COLUMN, RESERVED_KEYWORD},
  98         {"comment", COMMENT, UNRESERVED_KEYWORD},
  99         {"commit", COMMIT, UNRESERVED_KEYWORD},
 100         {"committed", COMMITTED, UNRESERVED_KEYWORD},
 101         {"concurrently", CONCURRENTLY, UNRESERVED_KEYWORD},
 102         {"configuration", CONFIGURATION, UNRESERVED_KEYWORD},
 103         {"connection", CONNECTION, UNRESERVED_KEYWORD},
 104         {"constraint", CONSTRAINT, RESERVED_KEYWORD},
 105         {"constraints", CONSTRAINTS, UNRESERVED_KEYWORD},
 106         {"content", CONTENT_P, UNRESERVED_KEYWORD},
 107         {"continue", CONTINUE_P, UNRESERVED_KEYWORD},
 108         {"conversion", CONVERSION_P, UNRESERVED_KEYWORD},
 109         {"copy", COPY, UNRESERVED_KEYWORD},
 110         {"cost", COST, UNRESERVED_KEYWORD},
 111         {"create", CREATE, RESERVED_KEYWORD},
 112         {"createdb", CREATEDB, UNRESERVED_KEYWORD},
 113         {"createrole", CREATEROLE, UNRESERVED_KEYWORD},
 114         {"createuser", CREATEUSER, UNRESERVED_KEYWORD},
 115         {"cross", CROSS, TYPE_FUNC_NAME_KEYWORD},
 116         {"csv", CSV, UNRESERVED_KEYWORD},
 117         {"ctype", CTYPE, UNRESERVED_KEYWORD},
 118         {"current", CURRENT_P, UNRESERVED_KEYWORD},
 119         {"current_date", CURRENT_DATE, RESERVED_KEYWORD},
 120         {"current_role", CURRENT_ROLE, RESERVED_KEYWORD},
 121         {"current_time", CURRENT_TIME, RESERVED_KEYWORD},
 122         {"current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD},
 123         {"current_user", CURRENT_USER, RESERVED_KEYWORD},
 124         {"cursor", CURSOR, UNRESERVED_KEYWORD},
 125         {"cycle", CYCLE, UNRESERVED_KEYWORD},
 126         {"database", DATABASE, UNRESERVED_KEYWORD},
 127         {"day", DAY_P, UNRESERVED_KEYWORD},
 128         {"deallocate", DEALLOCATE, UNRESERVED_KEYWORD},
 129         {"dec", DEC, COL_NAME_KEYWORD},
 130         {"decimal", DECIMAL_P, COL_NAME_KEYWORD},
 131         {"declare", DECLARE, UNRESERVED_KEYWORD},
 132         {"default", DEFAULT, RESERVED_KEYWORD},
 133         {"defaults", DEFAULTS, UNRESERVED_KEYWORD},
 134         {"deferrable", DEFERRABLE, RESERVED_KEYWORD},
 135         {"deferred", DEFERRED, UNRESERVED_KEYWORD},
 136         {"definer", DEFINER, UNRESERVED_KEYWORD},
 137         {"delete", DELETE_P, UNRESERVED_KEYWORD},
 138         {"delimiter", DELIMITER, UNRESERVED_KEYWORD},
 139         {"delimiters", DELIMITERS, UNRESERVED_KEYWORD},
 140         {"desc", DESC, RESERVED_KEYWORD},
 141         {"dictionary", DICTIONARY, UNRESERVED_KEYWORD},
 142         {"disable", DISABLE_P, UNRESERVED_KEYWORD},
 143         {"discard", DISCARD, UNRESERVED_KEYWORD},
 144         {"distinct", DISTINCT, RESERVED_KEYWORD},
 145         {"do", DO, RESERVED_KEYWORD},
 146         {"document", DOCUMENT_P, UNRESERVED_KEYWORD},
 147         {"domain", DOMAIN_P, UNRESERVED_KEYWORD},
 148         {"double", DOUBLE_P, UNRESERVED_KEYWORD},
 149         {"drop", DROP, UNRESERVED_KEYWORD},
 150         {"each", EACH, UNRESERVED_KEYWORD},
 151         {"else", ELSE, RESERVED_KEYWORD},
 152         {"enable", ENABLE_P, UNRESERVED_KEYWORD},
 153         {"encoding", ENCODING, UNRESERVED_KEYWORD},
 154         {"encrypted", ENCRYPTED, UNRESERVED_KEYWORD},
 155         {"end", END_P, RESERVED_KEYWORD},
 156         {"enum", ENUM_P, UNRESERVED_KEYWORD},
 157         {"escape", ESCAPE, UNRESERVED_KEYWORD},
 158         {"except", EXCEPT, RESERVED_KEYWORD},
 159         {"excluding", EXCLUDING, UNRESERVED_KEYWORD},
 160         {"exclusive", EXCLUSIVE, UNRESERVED_KEYWORD},
 161         {"execute", EXECUTE, UNRESERVED_KEYWORD},
 162         {"exists", EXISTS, COL_NAME_KEYWORD},
 163         {"explain", EXPLAIN, UNRESERVED_KEYWORD},
 164         {"external", EXTERNAL, UNRESERVED_KEYWORD},
 165         {"extract", EXTRACT, COL_NAME_KEYWORD},
 166         {"false", FALSE_P, RESERVED_KEYWORD},
 167         {"family", FAMILY, UNRESERVED_KEYWORD},
 168         {"fetch", FETCH, UNRESERVED_KEYWORD},
 169         {"first", FIRST_P, UNRESERVED_KEYWORD},
 170         {"float", FLOAT_P, COL_NAME_KEYWORD},
 171         {"for", FOR, RESERVED_KEYWORD},
 172         {"force", FORCE, UNRESERVED_KEYWORD},
 173         {"foreign", FOREIGN, RESERVED_KEYWORD},
 174         {"forward", FORWARD, UNRESERVED_KEYWORD},
 175         {"freeze", FREEZE, TYPE_FUNC_NAME_KEYWORD},
 176         {"from", FROM, RESERVED_KEYWORD},
 177         {"full", FULL, TYPE_FUNC_NAME_KEYWORD},
 178         {"function", FUNCTION, UNRESERVED_KEYWORD},
 179         {"global", GLOBAL, UNRESERVED_KEYWORD},
 180         {"grant", GRANT, RESERVED_KEYWORD},
 181         {"granted", GRANTED, UNRESERVED_KEYWORD},
 182         {"greatest", GREATEST, COL_NAME_KEYWORD},
 183         {"group", GROUP_P, RESERVED_KEYWORD},
 184         {"handler", HANDLER, UNRESERVED_KEYWORD},
 185         {"having", HAVING, RESERVED_KEYWORD},
 186         {"header", HEADER_P, UNRESERVED_KEYWORD},
 187         {"hold", HOLD, UNRESERVED_KEYWORD},
 188         {"hour", HOUR_P, UNRESERVED_KEYWORD},
 189         {"identity", IDENTITY_P, UNRESERVED_KEYWORD},
 190         {"if", IF_P, UNRESERVED_KEYWORD},
 191         {"ilike", ILIKE, TYPE_FUNC_NAME_KEYWORD},
 192         {"immediate", IMMEDIATE, UNRESERVED_KEYWORD},
 193         {"immutable", IMMUTABLE, UNRESERVED_KEYWORD},
 194         {"implicit", IMPLICIT_P, UNRESERVED_KEYWORD},
 195         {"in", IN_P, RESERVED_KEYWORD},
 196         {"including", INCLUDING, UNRESERVED_KEYWORD},
 197         {"increment", INCREMENT, UNRESERVED_KEYWORD},
 198         {"index", INDEX, UNRESERVED_KEYWORD},
 199         {"indexes", INDEXES, UNRESERVED_KEYWORD},
 200         {"inherit", INHERIT, UNRESERVED_KEYWORD},
 201         {"inherits", INHERITS, UNRESERVED_KEYWORD},
 202         {"initially", INITIALLY, RESERVED_KEYWORD},
 203         {"inner", INNER_P, TYPE_FUNC_NAME_KEYWORD},
 204         {"inout", INOUT, COL_NAME_KEYWORD},
 205         {"input", INPUT_P, UNRESERVED_KEYWORD},
 206         {"insensitive", INSENSITIVE, UNRESERVED_KEYWORD},
 207         {"insert", INSERT, UNRESERVED_KEYWORD},
 208         {"instead", INSTEAD, UNRESERVED_KEYWORD},
 209         {"int", INT_P, COL_NAME_KEYWORD},
 210         {"integer", INTEGER, COL_NAME_KEYWORD},
 211         {"intersect", INTERSECT, RESERVED_KEYWORD},
 212         {"interval", INTERVAL, COL_NAME_KEYWORD},
 213         {"into", INTO, RESERVED_KEYWORD},
 214         {"invoker", INVOKER, UNRESERVED_KEYWORD},
 215         {"is", IS, TYPE_FUNC_NAME_KEYWORD},
 216         {"isnull", ISNULL, TYPE_FUNC_NAME_KEYWORD},
 217         {"isolation", ISOLATION, UNRESERVED_KEYWORD},
 218         {"join", JOIN, TYPE_FUNC_NAME_KEYWORD},
 219         {"key", KEY, UNRESERVED_KEYWORD},
 220         {"lancompiler", LANCOMPILER, UNRESERVED_KEYWORD},
 221         {"language", LANGUAGE, UNRESERVED_KEYWORD},
 222         {"large", LARGE_P, UNRESERVED_KEYWORD},
 223         {"last", LAST_P, UNRESERVED_KEYWORD},
 224         {"leading", LEADING, RESERVED_KEYWORD},
 225         {"least", LEAST, COL_NAME_KEYWORD},
 226         {"left", LEFT, TYPE_FUNC_NAME_KEYWORD},
 227         {"level", LEVEL, UNRESERVED_KEYWORD},
 228         {"like", LIKE, TYPE_FUNC_NAME_KEYWORD},
 229         {"limit", LIMIT, RESERVED_KEYWORD},
 230         {"listen", LISTEN, UNRESERVED_KEYWORD},
 231         {"load", LOAD, UNRESERVED_KEYWORD},
 232         {"local", LOCAL, UNRESERVED_KEYWORD},
 233         {"localtime", LOCALTIME, RESERVED_KEYWORD},
 234         {"localtimestamp", LOCALTIMESTAMP, RESERVED_KEYWORD},
 235         {"location", LOCATION, UNRESERVED_KEYWORD},
 236         {"lock", LOCK_P, UNRESERVED_KEYWORD},
 237         {"login", LOGIN_P, UNRESERVED_KEYWORD},
 238         {"mapping", MAPPING, UNRESERVED_KEYWORD},
 239         {"match", MATCH, UNRESERVED_KEYWORD},
 240         {"maxvalue", MAXVALUE, UNRESERVED_KEYWORD},
 241         {"minute", MINUTE_P, UNRESERVED_KEYWORD},
 242         {"minvalue", MINVALUE, UNRESERVED_KEYWORD},
 243         {"mode", MODE, UNRESERVED_KEYWORD},
 244         {"month", MONTH_P, UNRESERVED_KEYWORD},
 245         {"move", MOVE, UNRESERVED_KEYWORD},
 246         {"name", NAME_P, UNRESERVED_KEYWORD},
 247         {"names", NAMES, UNRESERVED_KEYWORD},
 248         {"national", NATIONAL, COL_NAME_KEYWORD},
 249         {"natural", NATURAL, TYPE_FUNC_NAME_KEYWORD},
 250         {"nchar", NCHAR, COL_NAME_KEYWORD},
 251         {"new", NEW, RESERVED_KEYWORD},
 252         {"next", NEXT, UNRESERVED_KEYWORD},
 253         {"no", NO, UNRESERVED_KEYWORD},
 254         {"nocreatedb", NOCREATEDB, UNRESERVED_KEYWORD},
 255         {"nocreaterole", NOCREATEROLE, UNRESERVED_KEYWORD},
 256         {"nocreateuser", NOCREATEUSER, UNRESERVED_KEYWORD},
 257         {"noinherit", NOINHERIT, UNRESERVED_KEYWORD},
 258         {"nologin", NOLOGIN_P, UNRESERVED_KEYWORD},
 259         {"none", NONE, COL_NAME_KEYWORD},
 260         {"nosuperuser", NOSUPERUSER, UNRESERVED_KEYWORD},
 261         {"not", NOT, RESERVED_KEYWORD},
 262         {"nothing", NOTHING, UNRESERVED_KEYWORD},
 263         {"notify", NOTIFY, UNRESERVED_KEYWORD},
 264         {"notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD},
 265         {"nowait", NOWAIT, UNRESERVED_KEYWORD},
 266         {"null", NULL_P, RESERVED_KEYWORD},
 267         {"nullif", NULLIF, COL_NAME_KEYWORD},
 268         {"nulls", NULLS_P, UNRESERVED_KEYWORD},
 269         {"numeric", NUMERIC, COL_NAME_KEYWORD},
 270         {"object", OBJECT_P, UNRESERVED_KEYWORD},
 271         {"of", OF, UNRESERVED_KEYWORD},
 272         {"off", OFF, RESERVED_KEYWORD},
 273         {"offset", OFFSET, RESERVED_KEYWORD},
 274         {"oids", OIDS, UNRESERVED_KEYWORD},
 275         {"old", OLD, RESERVED_KEYWORD},
 276         {"on", ON, RESERVED_KEYWORD},
 277         {"only", ONLY, RESERVED_KEYWORD},
 278         {"operator", OPERATOR, UNRESERVED_KEYWORD},
 279         {"option", OPTION, UNRESERVED_KEYWORD},
 280         {"or", OR, RESERVED_KEYWORD},
 281         {"order", ORDER, RESERVED_KEYWORD},
 282         {"out", OUT_P, COL_NAME_KEYWORD},
 283         {"outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD},
 284         {"overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD},
 285         {"overlay", OVERLAY, COL_NAME_KEYWORD},
 286         {"owned", OWNED, UNRESERVED_KEYWORD},
 287         {"owner", OWNER, UNRESERVED_KEYWORD},
 288         {"parser", PARSER, UNRESERVED_KEYWORD},
 289         {"partial", PARTIAL, UNRESERVED_KEYWORD},
 290         {"password", PASSWORD, UNRESERVED_KEYWORD},
 291         {"placing", PLACING, RESERVED_KEYWORD},
 292         {"plans", PLANS, UNRESERVED_KEYWORD},
 293         {"position", POSITION, COL_NAME_KEYWORD},
 294         {"precision", PRECISION, COL_NAME_KEYWORD},
 295         {"prepare", PREPARE, UNRESERVED_KEYWORD},
 296         {"prepared", PREPARED, UNRESERVED_KEYWORD},
 297         {"preserve", PRESERVE, UNRESERVED_KEYWORD},
 298         {"primary", PRIMARY, RESERVED_KEYWORD},
 299         {"prior", PRIOR, UNRESERVED_KEYWORD},
 300         {"privileges", PRIVILEGES, UNRESERVED_KEYWORD},
 301         {"procedural", PROCEDURAL, UNRESERVED_KEYWORD},
 302         {"procedure", PROCEDURE, UNRESERVED_KEYWORD},
 303         {"quote", QUOTE, UNRESERVED_KEYWORD},
 304         {"read", READ, UNRESERVED_KEYWORD},
 305         {"real", REAL, COL_NAME_KEYWORD},
 306         {"reassign", REASSIGN, UNRESERVED_KEYWORD},
 307         {"recheck", RECHECK, UNRESERVED_KEYWORD},
 308         {"references", REFERENCES, RESERVED_KEYWORD},
 309         {"reindex", REINDEX, UNRESERVED_KEYWORD},
 310         {"relative", RELATIVE_P, UNRESERVED_KEYWORD},
 311         {"release", RELEASE, UNRESERVED_KEYWORD},
 312         {"rename", RENAME, UNRESERVED_KEYWORD},
 313         {"repeatable", REPEATABLE, UNRESERVED_KEYWORD},
 314         {"replace", REPLACE, UNRESERVED_KEYWORD},
 315         {"replica", REPLICA, UNRESERVED_KEYWORD},
 316         {"reset", RESET, UNRESERVED_KEYWORD},
 317         {"restart", RESTART, UNRESERVED_KEYWORD},
 318         {"restrict", RESTRICT, UNRESERVED_KEYWORD},
 319         {"returning", RETURNING, RESERVED_KEYWORD},
 320         {"returns", RETURNS, UNRESERVED_KEYWORD},
 321         {"revoke", REVOKE, UNRESERVED_KEYWORD},
 322         {"right", RIGHT, TYPE_FUNC_NAME_KEYWORD},
 323         {"role", ROLE, UNRESERVED_KEYWORD},
 324         {"rollback", ROLLBACK, UNRESERVED_KEYWORD},
 325         {"row", ROW, COL_NAME_KEYWORD},
 326         {"rows", ROWS, UNRESERVED_KEYWORD},
 327         {"rule", RULE, UNRESERVED_KEYWORD},
 328         {"savepoint", SAVEPOINT, UNRESERVED_KEYWORD},
 329         {"schema", SCHEMA, UNRESERVED_KEYWORD},
 330         {"scroll", SCROLL, UNRESERVED_KEYWORD},
 331         {"search", SEARCH, UNRESERVED_KEYWORD},
 332         {"second", SECOND_P, UNRESERVED_KEYWORD},
 333         {"security", SECURITY, UNRESERVED_KEYWORD},
 334         {"select", SELECT, RESERVED_KEYWORD},
 335         {"sequence", SEQUENCE, UNRESERVED_KEYWORD},
 336         {"serializable", SERIALIZABLE, UNRESERVED_KEYWORD},
 337         {"session", SESSION, UNRESERVED_KEYWORD},
 338         {"session_user", SESSION_USER, RESERVED_KEYWORD},
 339         {"set", SET, UNRESERVED_KEYWORD},
 340         {"setof", SETOF, COL_NAME_KEYWORD},
 341         {"share", SHARE, UNRESERVED_KEYWORD},
 342         {"show", SHOW, UNRESERVED_KEYWORD},
 343         {"similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD},
 344         {"simple", SIMPLE, UNRESERVED_KEYWORD},
 345         {"smallint", SMALLINT, COL_NAME_KEYWORD},
 346         {"some", SOME, RESERVED_KEYWORD},
 347         {"stable", STABLE, UNRESERVED_KEYWORD},
 348         {"standalone", STANDALONE_P, UNRESERVED_KEYWORD},
 349         {"start", START, UNRESERVED_KEYWORD},
 350         {"statement", STATEMENT, UNRESERVED_KEYWORD},
 351         {"statistics", STATISTICS, UNRESERVED_KEYWORD},
 352         {"stdin", STDIN, UNRESERVED_KEYWORD},
 353         {"stdout", STDOUT, UNRESERVED_KEYWORD},
 354         {"storage", STORAGE, UNRESERVED_KEYWORD},
 355         {"strict", STRICT_P, UNRESERVED_KEYWORD},
 356         {"strip", STRIP_P, UNRESERVED_KEYWORD},
 357         {"substring", SUBSTRING, COL_NAME_KEYWORD},
 358         {"superuser", SUPERUSER_P, UNRESERVED_KEYWORD},
 359         {"symmetric", SYMMETRIC, RESERVED_KEYWORD},
 360         {"sysid", SYSID, UNRESERVED_KEYWORD},
 361         {"system", SYSTEM_P, UNRESERVED_KEYWORD},
 362         {"table", TABLE, RESERVED_KEYWORD},
 363         {"tablespace", TABLESPACE, UNRESERVED_KEYWORD},
 364         {"temp", TEMP, UNRESERVED_KEYWORD},
 365         {"template", TEMPLATE, UNRESERVED_KEYWORD},
 366         {"temporary", TEMPORARY, UNRESERVED_KEYWORD},
 367         {"text", TEXT_P, UNRESERVED_KEYWORD},
 368         {"then", THEN, RESERVED_KEYWORD},
 369         {"time", TIME, COL_NAME_KEYWORD},
 370         {"timestamp", TIMESTAMP, COL_NAME_KEYWORD},
 371         {"to", TO, RESERVED_KEYWORD},
 372         {"trailing", TRAILING, RESERVED_KEYWORD},
 373         {"transaction", TRANSACTION, UNRESERVED_KEYWORD},
 374         {"treat", TREAT, COL_NAME_KEYWORD},
 375         {"trigger", TRIGGER, UNRESERVED_KEYWORD},
 376         {"trim", TRIM, COL_NAME_KEYWORD},
 377         {"true", TRUE_P, RESERVED_KEYWORD},
 378         {"truncate", TRUNCATE, UNRESERVED_KEYWORD},
 379         {"trusted", TRUSTED, UNRESERVED_KEYWORD},
 380         {"type", TYPE_P, UNRESERVED_KEYWORD},
 381         {"uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD},
 382         {"unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD},
 383         {"union", UNION, RESERVED_KEYWORD},
 384         {"unique", UNIQUE, RESERVED_KEYWORD},
 385         {"unknown", UNKNOWN, UNRESERVED_KEYWORD},
 386         {"unlisten", UNLISTEN, UNRESERVED_KEYWORD},
 387         {"until", UNTIL, UNRESERVED_KEYWORD},
 388         {"update", UPDATE, UNRESERVED_KEYWORD},
 389         {"user", USER, RESERVED_KEYWORD},
 390         {"using", USING, RESERVED_KEYWORD},
 391         {"vacuum", VACUUM, UNRESERVED_KEYWORD},
 392         {"valid", VALID, UNRESERVED_KEYWORD},
 393         {"validator", VALIDATOR, UNRESERVED_KEYWORD},
 394         {"value", VALUE_P, UNRESERVED_KEYWORD},
 395         {"values", VALUES, COL_NAME_KEYWORD},
 396         {"varchar", VARCHAR, COL_NAME_KEYWORD},
 397         {"variadic", VARIADIC, RESERVED_KEYWORD},
 398         {"varying", VARYING, UNRESERVED_KEYWORD},
 399         {"verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD},
 400         {"version", VERSION_P, UNRESERVED_KEYWORD},
 401         {"view", VIEW, UNRESERVED_KEYWORD},
 402         {"volatile", VOLATILE, UNRESERVED_KEYWORD},
 403         {"when", WHEN, RESERVED_KEYWORD},
 404         {"where", WHERE, RESERVED_KEYWORD},
 405         {"whitespace", WHITESPACE_P, UNRESERVED_KEYWORD},
 406
 407         /*
 408          * XXX we mark WITH as reserved to force it to be quoted in dumps, even
 409          * though it is currently unreserved according to gram.y.  This is because
 410          * we expect we'll have to make it reserved to implement SQL WITH clauses.
 411          * If that patch manages to do without reserving WITH, adjust this entry
 412          * at that time; in any case this should be back in sync with gram.y after
 413          * WITH clauses are implemented.
 414          */
 415         {"with", WITH, RESERVED_KEYWORD},
 416         {"without", WITHOUT, UNRESERVED_KEYWORD},
 417         {"work", WORK, UNRESERVED_KEYWORD},
 418         {"write", WRITE, UNRESERVED_KEYWORD},
 419         {"xml", XML_P, UNRESERVED_KEYWORD},
 420         {"xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD},
 421         {"xmlconcat", XMLCONCAT, COL_NAME_KEYWORD},
 422         {"xmlelement", XMLELEMENT, COL_NAME_KEYWORD},
 423         {"xmlforest", XMLFOREST, COL_NAME_KEYWORD},
 424         {"xmlparse", XMLPARSE, COL_NAME_KEYWORD},
 425         {"xmlpi", XMLPI, COL_NAME_KEYWORD},
 426         {"xmlroot", XMLROOT, COL_NAME_KEYWORD},
 427         {"xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD},
 428         {"year", YEAR_P, UNRESERVED_KEYWORD},
 429         {"yes", YES_P, UNRESERVED_KEYWORD},
 430         {"zone", ZONE, UNRESERVED_KEYWORD},
 431 };
 432
 433 /* End of ScanKeywords, for use elsewhere */
 434 const ScanKeyword *LastScanKeyword = endof(ScanKeywords);
 435
 436 /*
 437  * ScanKeywordLookup - see if a given word is a keyword
 438  *
 439  * Returns a pointer to the ScanKeyword table entry, or NULL if no match.
 440  *
 441  * The match is done case-insensitively.  Note that we deliberately use a
 442  * dumbed-down case conversion that will only translate 'A'-'Z' into 'a'-'z',
 443  * even if we are in a locale where tolower() would produce more or different
 444  * translations.  This is to conform to the SQL99 spec, which says that
 445  * keywords are to be matched in this way even though non-keyword identifiers
 446  * receive a different case-normalization mapping.
 447  */
 448 const ScanKeyword *
 449 ScanKeywordLookup(const char *text)
 450 {
 451         int                     len,
 452                                 i;
 453         char            word[NAMEDATALEN];
 454         const ScanKeyword *low;
 455         const ScanKeyword *high;
 456
 457         len = strlen(text);
 458         /* We assume all keywords are shorter than NAMEDATALEN. */
 459         if (len >= NAMEDATALEN)
 460                 return NULL;
 461
 462         /*
 463          * Apply an ASCII-only downcasing.      We must not use tolower() since it may
 464          * produce the wrong translation in some locales (eg, Turkish).
 465          */
 466         for (i = 0; i < len; i++)
 467         {
 468                 char            ch = text[i];
 469
 470                 if (ch >= 'A' && ch <= 'Z')
 471                         ch += 'a' - 'A';
 472                 word[i] = ch;
 473         }
 474         word[len] = '\0';
 475
 476         /*
 477          * Now do a binary search using plain strcmp() comparison.
 478          */
 479         low = &ScanKeywords[0];
 480         high = endof(ScanKeywords) - 1;
 481         while (low <= high)
 482         {
 483                 const ScanKeyword *middle;
 484                 int                     difference;
 485
 486                 middle = low + (high - low) / 2;
 487                 difference = strcmp(middle->name, word);
 488                 if (difference == 0)
 489                         return middle;
 490                 else if (difference < 0)
 491                         low = middle + 1;
 492                 else
 493                         high = middle - 1;
 494         }
 495
 496         return NULL;
 497 }