/* -*-C++-*- */
/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
/* -*-C++-*-
*******************************************************************************
*
* File:         ParKeyWords.cpp
* Description:  All keywords including those defined in ANSI 5.2,
*               Used by ulexer
*******************************************************************************
*/

#include "ComASSERT.h"
#include "ParKeyWords.h"
#include "str.h"
#include <fstream>

// ANSI SQL 99 reserved words added as COMPAQ_ reserved words if they were
// not already present in the table below.  Unreserved words were not
// considered.  Words already present, if not reserved, remain unreserved.
// No potentially reserved words in SQL 99.  None were added as compound
// key words.
// 001103 EJF

// Important notes for developers:
//
// If you are adding a keyword to Trafodion, you need to do the following:
//
// 1. Add it to the keyword table below. Use the appropriate flags in the
//    ParKeyWord object for your new keyword. (Note: Today the RESWORD_,
//    NONRESWORD_ and NONRESTOKEN_ flags are almost purely for documentation;
//    the real determination of whether a keyword is reserved or not depends
//    on how it is used in sqlparser.y. See point 3 below. Nevertheless,
//    it is useful documentation, and it might be used in the future, so
//    do try to get this right.)
// 2. Add a token definition for it to the parser (sqlparser.y). Add
//    and/or change any productions as needed to use your new token.
// 3. If your new keyword is *not* a reserved word (which is the usual case),
//    add it to the appropriate non-reserved word production in the parser.
//    That will allow the keyword to be used as a regular identifier in
//    contexts where keyword behavior is not intended. This avoids regressing
//    customer applications that might already be using that keyword as a 
//    regular identifier. See sqlparser.y, productions nonreserved_word and
//    nonreserved_func_word.
// 4. If your new keyword *is* a reserved word (this case should be rare),
//    add your keyword to the list of reserved words in ComResWords::resWords_
//    in common/ComResWords.cpp. This is important so that when an internal
//    representation of your keyword is used as an identifier, it will get
//    double quotes when converted to an external identifier. Failing to do
//    this will cause errors in some statements if your new keyword is used
//    as a delimited identifier.
// 5. If your new keyword commonly has a parenthesis after it, and it is
//    most natural for the parenthesis to be placed right after the keyword
//    (as opposed to having a space between keyword and paranthesis), then
//    add it to the keywords table in function tokIsFuncOrParenKeyword in
//    common/NAString.cpp. An example of this case is a new function name.
//    If my new function is XYZ, it looks more natural to generate XYZ(1)
//    rather than XYZ (1) in generated SQL text. An example of a case where
//    you would *not* want to do this might be adding a new logical operator
//    such as XOR. (A OR B) XOR (C OR D) looks more natural than 
//    (A OR B) XOR(C OR D). This is really an issue of esthetics rather than
//    correctness so this is not as critical as the previous four points.
// 6. Add test cases to regress/core/TEST037 of your new keyword.

// The keyword table:
//
ParKeyWord ParKeyWords::keyWords_[] = {
  ParKeyWord("ABORT",              TOK_ABORT,       NONRESTOKEN_),
  ParKeyWord("ABS",                TOK_ABS,         NONRESTOKEN_),
  ParKeyWord("ABSOLUTE",           IDENTIFIER,      ANS_|NONRESWORD_),
  // ABSOLUTE is a NONRESWORD_ for now (97/11/14) because
  // MicroStrategy is heavily using ABSOLUTE. Since we are not using
  // it yet, it is temporarily removed from the reserved word list
  // until MicroStrategy removes ABSOLUTE. It is too much work for
  // them to do that now.

  ParKeyWord("ACCESS",             TOK_ACCESS,      SECOND_|THIRD_|NONRESTOKEN_),
  ParKeyWord("ACCUMULATED",        TOK_ACCUMULATED, NONRESTOKEN_),
  ParKeyWord("ACOS",               TOK_ACOS,        NONRESTOKEN_),
  ParKeyWord("ACTION",             TOK_ACTION,      ANS_|RESWORD_),
  ParKeyWord("ACTIVATE",           TOK_ACTIVATE,      NONRESTOKEN_),
  ParKeyWord("ACTIVE",             TOK_ACTIVE,      NONRESTOKEN_),
  ParKeyWord("ADD",                TOK_ADD,         ANS_|RESWORD_),
  ParKeyWord("ADD_MONTHS",         TOK_ADD_MONTHS,  NONRESTOKEN_),
  ParKeyWord("ADMIN",              TOK_ADMIN,       COMPAQ_|RESWORD_),
  ParKeyWord("AES_ENCRYPT",        TOK_AES_ENCRYPT, NONRESTOKEN_),
  ParKeyWord("AES_DECRYPT",        TOK_AES_DECRYPT, NONRESTOKEN_),
  ParKeyWord("AFTER",              TOK_AFTER,       ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("AGGREGATE",          TOK_AGGREGATE,   COMPAQ_|RESWORD_),
  ParKeyWord("ALIAS",              TOK_ALIAS,       POTANS_|RESWORD_),
  ParKeyWord("ALIGNED",            TOK_ALIGNED,     NONRESTOKEN_),
  ParKeyWord("ALIGNED_LENGTH",     TOK_ALIGNED_LENGTH,     NONRESTOKEN_),
  ParKeyWord("ALL",                TOK_ALL,         ANS_|RESWORD_),
  ParKeyWord("ALL_DDL",            TOK_ALL_DDL,     NONRESTOKEN_),
  ParKeyWord("ALL_DML",            TOK_ALL_DML,     NONRESTOKEN_),
  ParKeyWord("ALL_UTILITY",        TOK_ALL_UTILITY, NONRESTOKEN_),
  ParKeyWord("ALLOCATE",           TOK_ALLOCATE,    ANS_|RESWORD_),
  ParKeyWord("ALLOW",              TOK_ALLOW,       NONRESTOKEN_),
  ParKeyWord("ALLOWED",            TOK_ALLOWED,     FLAGSNONE_),
  ParKeyWord("ALWAYS",             TOK_ALWAYS,      NONRESTOKEN_),
  ParKeyWord("ALTER",              TOK_ALTER,       ANS_|RESWORD_),
  ParKeyWord("ALTER_LIBRARY",      TOK_ALTER_LIBRARY,	NONRESTOKEN_),
  ParKeyWord("ALTER_MV",           TOK_ALTER_MV,	NONRESTOKEN_),
  ParKeyWord("ALTER_MV_GROUP",     TOK_ALTER_MV_GROUP,	NONRESTOKEN_),
  ParKeyWord("ALTER_ROUTINE",      TOK_ALTER_ROUTINE, NONRESTOKEN_),
  ParKeyWord("ALTER_ROUTINE_ACTION", TOK_ALTER_ROUTINE_ACTION, NONRESTOKEN_),
  ParKeyWord("ALTER_SYNONYM",      TOK_ALTER_SYNONYM,	NONRESTOKEN_),
  ParKeyWord("ALTER_TABLE",        TOK_ALTER_TABLE,	NONRESTOKEN_),
  ParKeyWord("ALTER_TRIGGER",      TOK_ALTER_TRIGGER,	NONRESTOKEN_),
  ParKeyWord("ALTER_VIEW",         TOK_ALTER_VIEW,	NONRESTOKEN_),
  ParKeyWord("AND",                TOK_AND,         ANS_|RESWORD_),
  ParKeyWord("ANSIVARCHAR",        TOK_ANSIVARCHAR, NONRESTOKEN_),
  ParKeyWord("ANY",                TOK_ANY,         ANS_|RESWORD_),
  ParKeyWord("APPEND",             TOK_APPEND,      NONRESTOKEN_),
  ParKeyWord("AQR",                TOK_AQR,         NONRESTOKEN_),
  ParKeyWord("AREA",               TOK_AREA,        NONRESTOKEN_),
  ParKeyWord("ARRAY",              TOK_ARRAY,       COMPAQ_|RESWORD_),
  ParKeyWord("ARE",                TOK_ARE,         ANS_|RESWORD_),
  ParKeyWord("AS",                 TOK_AS,          ANS_|RESWORD_),
  ParKeyWord("ASC",                TOK_ASC,         ANS_|RESWORD_),
  ParKeyWord("ASCENDING",          TOK_ASCENDING,   NONRESTOKEN_),
  ParKeyWord("ASCII",              TOK_ASCII,       NONRESTOKEN_),
  ParKeyWord("ASIN",               TOK_ASIN,        NONRESTOKEN_),
  ParKeyWord("ASSERTION",          TOK_ASSERTION,   ANS_|RESWORD_),
  ParKeyWord("ASYNC",              IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("AT",                 IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("ATAN",               TOK_ATAN,        NONRESTOKEN_),
  ParKeyWord("ATAN2",              TOK_ATAN2,       NONRESTOKEN_),
  ParKeyWord("ATOMIC",             TOK_ATOMIC,      NONRESTOKEN_),
  ParKeyWord("ATTRIBUTE",          TOK_ATTRIBUTE,   NONRESTOKEN_),
  ParKeyWord("ATTRIBUTES",         TOK_ATTRIBUTES,  NONRESTOKEN_),
  ParKeyWord("AUDIT",              TOK_AUDIT,       NONRESTOKEN_),
  ParKeyWord("AUDITCOMPRESS",      TOK_AUDITCOMPRESS, NONRESTOKEN_),
  ParKeyWord("AUTHENTICATION",     TOK_AUTHENTICATION, NONRESTOKEN_),
  ParKeyWord("AUDITONREFRESH",     TOK_AUDITONREFRESH, FLAGSNONE_),
  ParKeyWord("AUTHNAME",           TOK_AUTHNAME,    NONRESTOKEN_),
  ParKeyWord("AUTHORIZATION",      TOK_AUTHORIZATION, ANS_|RESWORD_),
  ParKeyWord("AUTHTYPE",           TOK_AUTHTYPE,    NONRESTOKEN_),
  ParKeyWord("AUTOABORT",          TOK_AUTOABORT,   NONRESTOKEN_),
  ParKeyWord("AUTOBEGIN",          TOK_AUTOBEGIN,   NONRESTOKEN_),
  ParKeyWord("AUTOCOMMIT",         TOK_AUTOCOMMIT,  NONRESTOKEN_),
  ParKeyWord("AUTOMATIC",          TOK_AUTOMATIC, FLAGSNONE_),
  ParKeyWord("AVERAGE_STREAM_WAIT", TOK_AVERAGE_STREAM_WAIT, NONRESTOKEN_),
  ParKeyWord("AVG",                TOK_AVG,         ANS_|RESWORD_),
  ParKeyWord("BACKUP",             TOK_BACKUP,      NONRESTOKEN_),
  ParKeyWord("BALANCE",            TOK_BALANCE,     NONRESTOKEN_),
  ParKeyWord("BEFORE",             TOK_BEFORE,      ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("BEGIN",              TOK_BEGIN,       ANS_|RESWORD_),
  ParKeyWord("BETWEEN",            TOK_BETWEEN,     SECOND_|ANS_|RESWORD_),
  ParKeyWord("BIGINT",             TOK_BIGINT,      NONRESTOKEN_),
  ParKeyWord("BINARY",             TOK_BINARY,      COMPAQ_|RESWORD_),
  ParKeyWord("BIT",                TOK_BIT,         ANS_|RESWORD_),
  ParKeyWord("BITAND",             TOK_BITAND,      NONRESTOKEN_),
  ParKeyWord("BITEXTRACT",         TOK_BITEXTRACT,  NONRESTOKEN_),
  ParKeyWord("BITNOT",             TOK_BITNOT,      NONRESTOKEN_),
  ParKeyWord("BITOR",              TOK_BITOR,       NONRESTOKEN_),
  ParKeyWord("BITXOR",             TOK_BITXOR,      NONRESTOKEN_),
  ParKeyWord("BIT_LENGTH",         IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("BLOB",               TOK_BLOB,        COMPAQ_|RESWORD_),
  ParKeyWord("BLOCKS",             TOK_BLOCKS,      NONRESTOKEN_),
  ParKeyWord("BLOCKSIZE",          TOK_BLOCKSIZE,   NONRESTOKEN_),
  ParKeyWord("BOOLEAN",            TOK_BOOLEAN,     RESWORD_),
  ParKeyWord("BOTH",               TOK_BOTH,        ANS_|RESWORD_),
  ParKeyWord("BREADTH",            IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("BRIEF",              TOK_BRIEF,       NONRESTOKEN_),
  ParKeyWord("BT",                 TOK_BT,          NONRESTOKEN_),
  ParKeyWord("BUFFER",             TOK_BUFFER,      NONRESTOKEN_),
  ParKeyWord("BUFFERED",           TOK_BUFFERED,    NONRESTOKEN_),
  ParKeyWord("BUFFERTOLOB",        TOK_BUFFERTOLOB, NONRESTOKEN_),
  ParKeyWord("BY",                 TOK_BY,          SECOND_|ANS_|RESWORD_),
  ParKeyWord("BYTE",               TOK_BYTE,        NONRESTOKEN_),
  ParKeyWord("BYTEINT",            TOK_BYTEINT,     NONRESTOKEN_),
  ParKeyWord("BYTES",              TOK_BYTES,       NONRESTOKEN_),
  ParKeyWord("C",                  TOK_C,           NONRESTOKEN_),
  ParKeyWord("CPP",                TOK_CPP,         NONRESTOKEN_),
  ParKeyWord("CACHE",              TOK_CACHE,       NONRESTOKEN_),
  ParKeyWord("CALL",               TOK_CALL,        FIRST_|POTANS_|RESWORD_),
  ParKeyWord("CANCEL",             TOK_CANCEL,      NONRESTOKEN_),
  ParKeyWord("CAPTURE",             TOK_CAPTURE,      NONRESTOKEN_),
  ParKeyWord("CARDINALITY",        TOK_CARDINALITY, NONRESTOKEN_),
  ParKeyWord("CASCADE",            TOK_CASCADE,     ANS_|RESWORD_),
  ParKeyWord("CASCADED",           TOK_CASCADED,    ANS_|RESWORD_),
  ParKeyWord("CASE",               TOK_CASE,        ANS_|RESWORD_),
  ParKeyWord("CASESPECIFIC",       TOK_CASESPECIFIC, SECOND_|NONRESTOKEN_),  
  ParKeyWord("CAST",               TOK_CAST,        ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("CATALOG",            TOK_CATALOG,     ANS_|RESWORD_),
  ParKeyWord("CATALOGS",           TOK_CATALOGS,    NONRESTOKEN_),
  ParKeyWord("CATALOG_NAME",       TOK_CATALOG_NAME, NONRESTOKEN_),
  ParKeyWord("CATCHUP",            TOK_CATCHUP,     FLAGSNONE_),
  ParKeyWord("CEIL",               TOK_CEIL,        NONRESTOKEN_),
  ParKeyWord("CEILING",            TOK_CEILING,     NONRESTOKEN_),
  ParKeyWord("CENTURY",            TOK_CENTURY,     NONRESTOKEN_),
  ParKeyWord("CHANGED",            TOK_CHANGED,     NONRESTOKEN_),
  ParKeyWord("CHANGES",            TOK_CHANGES,     FLAGSNONE_),
  ParKeyWord("CHAR",               TOK_CHAR,        ANS_|RESWORD_),
  ParKeyWord("CHARS",              TOK_CHARS,       NONRESTOKEN_),
  ParKeyWord("CHR",                TOK_CHR,         NONRESTOKEN_),
  ParKeyWord("CHARACTER",          TOK_CHARACTER,   ANS_|RESWORD_),
  ParKeyWord("CHARACTERS",         TOK_CHARACTERS,  NONRESTOKEN_),
  ParKeyWord("CHARACTER_LENGTH",   TOK_CHAR_LENGTH, ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("CHARACTER_SET_CATALOG", TOK_CHARACTER_SET_CATALOG, NONRESTOKEN_),
  ParKeyWord("CHARACTER_SET_NAME", TOK_CHARACTER_SET_NAME, NONRESTOKEN_),
  ParKeyWord("CHARACTER_SET_SCHEMA", TOK_CHARACTER_SET_SCHEMA, NONRESTOKEN_),
  ParKeyWord("CHAR_LENGTH",        TOK_CHAR_LENGTH, ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("CHECK",              TOK_CHECK,       ANS_|RESWORD_),
  ParKeyWord("CHECKSUM",           TOK_CHECKSUM,    NONRESTOKEN_),
  ParKeyWord("CLASS",              TOK_CLASS,       COMPAQ_|RESWORD_),
  ParKeyWord("CLASS_ORIGIN",       TOK_CLASS_ORIGIN, NONRESTOKEN_),
  ParKeyWord("CLEAN",              TOK_CLEAN,     NONRESTOKEN_),
  ParKeyWord("CLEANUP",            TOK_CLEANUP,     FIRST_ | NONRESTOKEN_),
  ParKeyWord("CLEAR",              TOK_CLEAR,       NONRESTOKEN_),
  ParKeyWord("CLEARONPURGE",       TOK_CLEARONPURGE, NONRESTOKEN_),
  ParKeyWord("CLOB",               TOK_CLOB,        COMPAQ_|RESWORD_),
  ParKeyWord("CLOSE",              TOK_CLOSE,       ANS_|RESWORD_),
  ParKeyWord("CLUSTER",            TOK_CLUSTER,     NONRESTOKEN_),
  ParKeyWord("CLUSTERING",         TOK_CLUSTERING,    NONRESTOKEN_),
  ParKeyWord("CLUSTERS",           TOK_CLUSTERS,    NONRESTOKEN_),
  ParKeyWord("COMPILE",            TOK_COMPILE,     NONRESTOKEN_),
  ParKeyWord("CMP",                TOK_ARKCMP,      NONRESTOKEN_),
  ParKeyWord("COALESCE",           TOK_COALESCE,    ANS_|RESWORD_),
  ParKeyWord("CODE_VALUE",         TOK_CODE_VALUE,  NONRESTOKEN_),
  ParKeyWord("COLLATE",            TOK_COLLATE,     ANS_|RESWORD_),
  ParKeyWord("COLLATION",          TOK_COLLATION,   ANS_|RESWORD_),
  ParKeyWord("COLLATION_CATALOG",  TOK_COLLATION_CATALOG, NONRESTOKEN_),
  ParKeyWord("COLLATION_NAME",     TOK_COLLATION_NAME, NONRESTOKEN_),
  ParKeyWord("COLLATION_SCHEMA",   TOK_COLLATION_SCHEMA, NONRESTOKEN_),
  ParKeyWord("COLUMN",             TOK_COLUMN,      ANS_|RESWORD_),
  ParKeyWord("COLUMN_CREATE",        TOK_COLUMN_CREATE, NONRESTOKEN_),
  ParKeyWord("COLUMN_DISPLAY",        TOK_COLUMN_DISPLAY, NONRESTOKEN_),
  ParKeyWord("COLUMN_LOOKUP",        TOK_COLUMN_LOOKUP, NONRESTOKEN_),
  ParKeyWord("COLUMN_NAME",        TOK_COLUMN_NAME, NONRESTOKEN_),
  ParKeyWord("COLUMN_NUMBER",      TOK_COLUMN_NUMBER, NONRESTOKEN_),
  ParKeyWord("COLUMNS",            TOK_COLUMNS, FLAGSNONE_),
  ParKeyWord("COMMAND_FUNCTION",   TOK_COMMAND_FUNCTION, NONRESTOKEN_),
  ParKeyWord("COMMANDS",           TOK_COMMANDS, NONRESTOKEN_),
  ParKeyWord("COMMENT",            TOK_COMMENT, NONRESTOKEN_),
  ParKeyWord("COMMIT",             TOK_COMMIT,      SECOND_|ANS_|RESWORD_),
  ParKeyWord("COMMITTED",          TOK_COMMITTED,   NONRESTOKEN_),
  ParKeyWord("COMP",               TOK_COMP,        NONRESTOKEN_),
  ParKeyWord("COMPACT",            TOK_COMPACT,     NONRESTOKEN_),
  ParKeyWord("COMPARE",            TOK_COMPARE,        NONRESTOKEN_),
  ParKeyWord("COMPLETE",           TOK_COMPLETE,   NONRESTOKEN_),
  ParKeyWord("COMPLETION",         IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("COMPONENT",          TOK_COMPONENT,   NONRESTOKEN_|SECOND_),
  ParKeyWord("COMPONENTS",         TOK_COMPONENTS,  NONRESTOKEN_),
  ParKeyWord("COMPRESS",           TOK_COMPRESS,    NONRESTOKEN_),
  ParKeyWord("COMPRESSION",        TOK_COMPRESSION, NONRESTOKEN_),
  ParKeyWord("COMPRESSED",         TOK_COMPRESSED,  NONRESTOKEN_),
  ParKeyWord("CONCAT",             TOK_CONCAT,      NONRESTOKEN_),
  ParKeyWord("CONCURRENCY",        TOK_CONCURRENCY, NONRESTOKEN_),
  ParKeyWord("CONCURRENT",         TOK_CONCURRENT,  NONRESTOKEN_),
  ParKeyWord("CONDITION_NUMBER",   TOK_CONDITION_NUMBER, NONRESTOKEN_),
  ParKeyWord("CONFIG",             TOK_CONFIG,      NONRESTOKEN_),
  ParKeyWord("CONFLICT",           TOK_CONFLICT,    SECOND_|NONRESTOKEN_),
  ParKeyWord("CONNECT",            IDENTIFIER,      ANS_|RESWORD_),
  //  ParKeyWord("CONNECTION",         IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("CONNECTION_NAME",    TOK_CONNECTION_NAME, NONRESTOKEN_),
  ParKeyWord("CONSTRAINT",         TOK_CONSTRAINT,  ANS_|RESWORD_),
  ParKeyWord("CONSTRAINTS",        TOK_CONSTRAINTS, ANS_|RESWORD_),
  ParKeyWord("CONSTRAINT_CATALOG", TOK_CONSTRAINT_CATALOG, NONRESTOKEN_),
  ParKeyWord("CONSTRAINT_NAME",    TOK_CONSTRAINT_NAME, NONRESTOKEN_),
  ParKeyWord("CONSTRAINT_SCHEMA",  TOK_CONSTRAINT_SCHEMA, NONRESTOKEN_),
  ParKeyWord("CONSTRUCTOR",        TOK_CONSTRUCTOR, COMPAQ_|RESWORD_),
  ParKeyWord("CONTAINS",           TOK_CONTAINS,    NONRESTOKEN_),
  ParKeyWord("CONTINUE",           TOK_CONTINUE,    ANS_|RESWORD_),
  ParKeyWord("CONTROL",            TOK_CONTROL,     NONRESTOKEN_),
  ParKeyWord("CONVERT",            TOK_CONVERT,     ANS_|RESWORD_),
  ParKeyWord("CONVERTFROMHEX",     TOK_CONVERTFROMHEX, NONRESTOKEN_),
  ParKeyWord("CONVERTTIMESTAMP",   TOK_CONVERTTIMESTAMP, NONRESTOKEN_),
  ParKeyWord("CONVERTTOBITS",      TOK_CONVERTTOBITS, NONRESTOKEN_),
  ParKeyWord("CONVERTTOHEX",       TOK_CONVERTTOHEX, NONRESTOKEN_),
  ParKeyWord("CONVERTTOHX_INTN",   TOK_CONVERTTOHX_INTN, NONRESTOKEN_),
  ParKeyWord("CORRESPONDING",      TOK_CORRESPONDING, ANS_|RESWORD_),
  ParKeyWord("COS",                TOK_COS,         NONRESTOKEN_),
  ParKeyWord("COSH",               TOK_COSH,        NONRESTOKEN_),
  ParKeyWord("COST",               TOK_COST,        NONRESTOKEN_),
  ParKeyWord("COUNT",              TOK_COUNT,       ANS_|RESWORD_),
  ParKeyWord("COPY",               TOK_COPY,        NONRESTOKEN_),
  ParKeyWord("CPU",                TOK_CPU,         NONRESTOKEN_),
  ParKeyWord("CQD",                TOK_CQD,         NONRESTOKEN_),
  ParKeyWord("CRC32",              TOK_CRC32,       NONRESTOKEN_),
  ParKeyWord("CREATE",             TOK_CREATE,      ANS_|RESWORD_),
  ParKeyWord("CREATE_LIBRARY",     TOK_CREATE_LIBRARY,   NONRESTOKEN_),
  ParKeyWord("CREATE_MV",          TOK_CREATE_MV,   NONRESTOKEN_),
  ParKeyWord("CREATE_MV_GROUP",    TOK_CREATE_MV_GROUP,   NONRESTOKEN_),
  ParKeyWord("CREATE_PROCEDURE",   TOK_CREATE_PROCEDURE, NONRESTOKEN_),
  ParKeyWord("CREATE_ROUTINE",     TOK_CREATE_ROUTINE, NONRESTOKEN_),
  ParKeyWord("CREATE_ROUTINE_ACTION", TOK_CREATE_ROUTINE_ACTION, NONRESTOKEN_),
  ParKeyWord("CREATE_TABLE",       TOK_CREATE_TABLE, NONRESTOKEN_),
  ParKeyWord("CREATE_TRIGGER",     TOK_CREATE_TRIGGER, NONRESTOKEN_),
  ParKeyWord("CREATE_SYNONYM",     TOK_CREATE_SYNONYM, NONRESTOKEN_),
  ParKeyWord("CREATE_VIEW",        TOK_CREATE_VIEW, NONRESTOKEN_),
  ParKeyWord("CROSS",              TOK_CROSS,       ANS_|RESWORD_),
  ParKeyWord("CUBE",               TOK_CUBE,        COMPAQ_|RESWORD_),
  ParKeyWord("CURDATE",            TOK_CURDATE,     NONRESTOKEN_),
  ParKeyWord("CURRENT",            TOK_CURRENT,     ANS_|RESWORD_),
  ParKeyWord("CURRENT_DATE",       TOK_CURRENT_DATE, ANS_|RESWORD_),
  ParKeyWord("CURRENT_PATH",       TOK_CURRENT_PATH, COMPAQ_|RESWORD_),
  ParKeyWord("CURRENT_RUNNING",    TOK_CURRENT_RUNNING,     NONRESTOKEN_),
  ParKeyWord("CURRENT_TIME",       TOK_CURRENT_TIME, ANS_|RESWORD_),
  ParKeyWord("CURRENT_TIMESTAMP",  TOK_CURRENT_TIMESTAMP, ANS_|RESWORD_),
  ParKeyWord("CURRENT_TIMESTAMP_RUNNING",    TOK_CURRENT_TIMESTAMP_RUNNING,     NONRESTOKEN_),
  ParKeyWord("CURRENT_TIMESTAMP_UTC",    TOK_CURRENT_TIMESTAMP_UTC,     NONRESTOKEN_),
  ParKeyWord("CURRENT_TIME_UTC",   TOK_CURRENT_TIME_UTC,     NONRESTOKEN_),
  ParKeyWord("CURRENT_USER",       TOK_CURRENT_USER, ANS_|RESWORD_),
  ParKeyWord("CURRNT_USR_INTN",    TOK_CURRNT_USR_INTN, RESWORD_),
  ParKeyWord("CURSOR",             TOK_CURSOR,      FIRST_|ANS_|RESWORD_),
  ParKeyWord("CURSOR_NAME",        TOK_CURSOR_NAME, NONRESTOKEN_),
  ParKeyWord("CURTIME",            TOK_CURTIME,     NONRESTOKEN_),
  ParKeyWord("CYCLE",              TOK_CYCLE,       ANS_|RESWORD_),
  ParKeyWord("D",                  TOK_D,           NONRESTOKEN_),
  ParKeyWord("DATA",               TOK_DATA,        POTANS_|NONRESTOKEN_|NONRESWORD_),
  // The word DATA is used in several places in mxcmp (ISP and RFORK),
  // and is in SqlParser.y's "nonreserved_word" list, so we have not
  // made it reserved even though it is in the potential ANSI reserved
  // word list.

  ParKeyWord("DATABASE",           TOK_DATABASE,    NONRESTOKEN_),
  ParKeyWord("DATA_OFFSET",        TOK_DATA_OFFSET, NONRESTOKEN_),
  ParKeyWord("DATE",               TOK_DATE,        FIRST_|ANS_|RESWORD_),
  ParKeyWord("DATEADD",            TOK_DATEADD,     NONRESTOKEN_),
  ParKeyWord("DATE_ADD",           TOK_DATE_ADD,    NONRESTOKEN_),
  ParKeyWord("DATE_PART",          TOK_DATE_PART,   NONRESTOKEN_),
  ParKeyWord("DATE_TRUNC",         TOK_DATE_TRUNC,  NONRESTOKEN_),
  ParKeyWord("DATEDIFF",           TOK_DATEDIFF,    NONRESTOKEN_),
  ParKeyWord("DATE_SUB",           TOK_DATE_SUB,    NONRESTOKEN_),
  ParKeyWord("DATEFORMAT",         TOK_DATEFORMAT,  NONRESTOKEN_),
  ParKeyWord("DATETIME",           TOK_DATETIME,    COMPAQ_|RESWORD_),
  ParKeyWord("DATETIME_CODE",      TOK_DATETIME_CODE, NONRESTOKEN_),
  ParKeyWord("DAY",                TOK_DAY,         ANS_|RESWORD_),
  ParKeyWord("DAYNAME",            TOK_DAYNAME,     NONRESTOKEN_),
  ParKeyWord("DAYOFMONTH",         TOK_DAYOFMONTH,  NONRESTOKEN_),
  ParKeyWord("DAYOFWEEK",          TOK_DAYOFWEEK,   NONRESTOKEN_),
  ParKeyWord("DAYOFYEAR",          TOK_DAYOFYEAR,   NONRESTOKEN_),
  ParKeyWord("DB",                 TOK_DATABASE,    NONRESTOKEN_),
  ParKeyWord("DBA",		   TOK_DBA,	    NONRESTOKEN_),
  ParKeyWord("DCOMPRESS",          TOK_DCOMPRESS,   NONRESTOKEN_),
  ParKeyWord("DDL",                TOK_DDL,         NONRESTOKEN_),
  ParKeyWord("DE",                 TOK_DE,          FLAGSNONE_),
  ParKeyWord("DEALLOCATE",         TOK_DEALLOCATE,  ANS_|RESWORD_),
  ParKeyWord("DEBUG",              TOK_DEBUG,       NONRESTOKEN_),
  ParKeyWord("DEC",                TOK_DECIMAL,     ANS_|RESWORD_),
  ParKeyWord("DECIMAL",            TOK_DECIMAL,     ANS_|RESWORD_),
  ParKeyWord("DECADE",             TOK_DECADE,      NONRESTOKEN_),
  ParKeyWord("DECODE",             TOK_DECODE,      NONRESTOKEN_),
  ParKeyWord("DECLARE",            TOK_DECLARE,     ANS_|RESWORD_),
  ParKeyWord("DEFAULT",            TOK_DEFAULT,     SECOND_|ANS_|RESWORD_),
  ParKeyWord("DEFAULTS",           TOK_DEFAULTS,    NONRESTOKEN_),
  ParKeyWord("DEFERRABLE",         IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("DEFERRED",           IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("DEFINER",            TOK_DEFINER,     NONRESTOKEN_),
  ParKeyWord("DEFINITION",         TOK_DEFINITION,  NONRESTOKEN_),
  ParKeyWord("DEGREES",            TOK_DEGREES,     NONRESTOKEN_),
  ParKeyWord("DELAY",              TOK_DELAY,       NONRESTOKEN_),
  ParKeyWord("DELETE",             TOK_DELETE,      ANS_|RESWORD_),
  ParKeyWord("DELIMITER",          TOK_DELIMITER,   NONRESTOKEN_),
  ParKeyWord("DEPENDENT", 	   TOK_DEPENDENT,   NONRESTOKEN_),
  ParKeyWord("DENSE_RANK",         TOK_D_RANK,      NONRESTOKEN_),
  ParKeyWord("DEPTH",              IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("DEREF",              TOK_DEREF,       COMPAQ_|RESWORD_),
  ParKeyWord("DESC",               TOK_DESC,        ANS_|RESWORD_),
  ParKeyWord("DESCENDING",         TOK_DESCENDING,  NONRESTOKEN_),
  ParKeyWord("DESCRIBE",           TOK_DESCRIBE,    ANS_|RESWORD_),
  ParKeyWord("DESCRIPTOR",         TOK_DESCRIPTOR,  ANS_|RESWORD_),
  ParKeyWord("DESTROY",            TOK_DESTROY,     COMPAQ_|RESWORD_),
  ParKeyWord("DESTRUCTOR",         TOK_DESTRUCTOR,  COMPAQ_|RESWORD_),
  ParKeyWord("DETAIL",             TOK_DETAIL,      NONRESTOKEN_),
  ParKeyWord("DETAILS",            TOK_DETAILS,      NONRESTOKEN_),
  ParKeyWord("DETERMINISTIC",      TOK_DETERMINISTIC, COMPAQ_|RESWORD_),
  ParKeyWord("DIAGNOSTICS",        TOK_DIAGNOSTICS, ANS_|RESWORD_),
  ParKeyWord("DICTIONARY",         IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("DIFF1",              TOK_DIFF1,       NONRESTOKEN_),
  ParKeyWord("DIFF2",              TOK_DIFF2,       NONRESTOKEN_),
  ParKeyWord("DIRECTEDBY",         TOK_DIRECTEDBY,  FLAGSNONE_),
  ParKeyWord("DISABLE",            TOK_DISABLE,     NONRESTOKEN_),
  ParKeyWord("DISCONNECT",         IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("DISK",		   TOK_DISK,        NONRESTOKEN_),
  ParKeyWord("DISPLAY",            TOK_DISPLAY,     NONRESTOKEN_),
  ParKeyWord("DISTINCT",           TOK_DISTINCT,    ANS_|RESWORD_),
  ParKeyWord("DIVISION",           TOK_DIVISION,    NONRESTOKEN_),
  ParKeyWord("DO",                 TOK_DO,          NONRESTOKEN_),
  ParKeyWord("DOMAIN",             IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("DOUBLE",             TOK_DOUBLE,      ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("DOUBLE_IEEE",        TOK_DOUBLE_IEEE, NONRESTOKEN_),
  ParKeyWord("DOW",                TOK_DOW,         NONRESTOKEN_),
  ParKeyWord("DOY",                TOK_DOY,         NONRESTOKEN_),
  ParKeyWord("DROP",               TOK_DROP,        ANS_|RESWORD_),
  ParKeyWord("DROPPABLE",          TOK_DROPPABLE,   SECOND_|NONRESTOKEN_),
  ParKeyWord("DROP_LIBRARY",       TOK_DROP_LIBRARY,	  NONRESTOKEN_),
  ParKeyWord("DROP_MV",            TOK_DROP_MV,		  NONRESTOKEN_),
  ParKeyWord("DROP_MV_GROUP",      TOK_DROP_MV_GROUP,	  NONRESTOKEN_),
  ParKeyWord("DROP_PROCEDURE",     TOK_DROP_PROCEDURE,	  NONRESTOKEN_),
  ParKeyWord("DROP_ROUTINE",       TOK_DROP_ROUTINE, NONRESTOKEN_),
  ParKeyWord("DROP_ROUTINE_ACTION", TOK_DROP_ROUTINE_ACTION, NONRESTOKEN_),
  ParKeyWord("DROP_SYNONYM",       TOK_DROP_SYNONYM,	  NONRESTOKEN_),
  ParKeyWord("DROP_TABLE",         TOK_DROP_TABLE,	  NONRESTOKEN_),
  ParKeyWord("DROP_TRIGGER",       TOK_DROP_TRIGGER,	  NONRESTOKEN_),
  ParKeyWord("DROP_VIEW",	   TOK_DROP_VIEW,	  NONRESTOKEN_),
  ParKeyWord("DSLACK",             TOK_DSLACK,      NONRESTOKEN_),
  ParKeyWord("DUAL",               TOK_DUAL,        NONRESTOKEN_),  
  ParKeyWord("DUPLICATE",          TOK_DUPLICATE,        NONRESTOKEN_),
  ParKeyWord("DYNAMIC",            TOK_DYNAMIC,     COMPAQ_|RESWORD_),
  ParKeyWord("DYNAMIC_FUNCTION",   TOK_DYNAMIC_FUNCTION, NONRESTOKEN_),
  ParKeyWord("EACH",               TOK_EACH,        ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("EID",                TOK_EID,         NONRESTOKEN_),  
  ParKeyWord("ELSE",               TOK_ELSE,        ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("ELSEIF",             TOK_ELSEIF,      POTANS_|RESWORD_),
  ParKeyWord("ENABLE",             TOK_ENABLE,      NONRESTOKEN_),
  ParKeyWord("ENCODE_KEY",         TOK_ENCODE_KEY,  NONRESTOKEN_),
  ParKeyWord("END",                TOK_END,         ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("END-EXEC",           IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("ENFORCED",           TOK_ENFORCED,    SECOND_|NONRESTOKEN_),
  ParKeyWord("ENFORCERS",          TOK_ENFORCERS,   NONRESTOKEN_),
  ParKeyWord("ENTERPRISE",         TOK_ENTERPRISE,  NONRESTOKEN_),
  ParKeyWord("ENTRIES",            TOK_ENTRIES,     NONRESTOKEN_),
  ParKeyWord("ENTRY",              TOK_ENTRY,       NONRESTOKEN_),
  ParKeyWord("ENVVAR",             TOK_ENVVAR,      NONRESTOKEN_),
  ParKeyWord("ENVVARS",            TOK_ENVVARS,     NONRESTOKEN_),
  ParKeyWord("EOF",                TOK_EOF,         NONRESTOKEN_),
  ParKeyWord("EPOCH",              TOK_EPOCH,       NONRESTOKEN_),
  ParKeyWord("EQUALS",             IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("ERROR",              TOK_ERROR,       NONRESTOKEN_),
  ParKeyWord("ESCAPE",             TOK_ESCAPE,      ANS_|RESWORD_),
  ParKeyWord("ET",                 TOK_ET,          NONRESTOKEN_),
  ParKeyWord("EUROPEAN",           TOK_EUROPEAN,    NONRESTOKEN_),
  ParKeyWord("EVERY",              TOK_EVERY,       NONRESTOKEN_),
  ParKeyWord("EXCEPT",             TOK_EXCEPT,      ANS_|RESWORD_),
  ParKeyWord("EXCEPTION",          TOK_EXCEPTION,   ANS_|RESWORD_),
  ParKeyWord("EXCEPTION_TABLE",    TOK_EXCEPTION_TABLE,     NONRESTOKEN_),
  ParKeyWord("EXCHANGE",           TOK_EXCHANGE,    NONRESTOKEN_),
  ParKeyWord("EXCHANGE_AND_SORT",  TOK_EXCHANGE_AND_SORT, NONRESTOKEN_),
  ParKeyWord("EXCLUSIVE",          TOK_EXCLUSIVE,   NONRESTOKEN_),
  ParKeyWord("EXEC",               IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("EXECUTE",            TOK_EXECUTE,     ANS_|RESWORD_),
  ParKeyWord("EXECUTION",          TOK_EXECUTION,   NONRESTOKEN_),
  ParKeyWord("EXISTING",           TOK_EXISTING,    NONRESTOKEN_),
  ParKeyWord("EXISTS",             TOK_EXISTS,      ANS_|RESWORD_),
  ParKeyWord("EXIT",               TOK_EXIT,        NONRESTOKEN_),
  ParKeyWord("EXP",                TOK_EXP,         NONRESTOKEN_),
  ParKeyWord("EXPLAIN",            TOK_EXPLAIN,     NONRESTOKEN_),
  ParKeyWord("EXTEND",             TOK_EXTEND,      NONRESTOKEN_),
  ParKeyWord("EXTENT",             TOK_EXTENT,      NONRESTOKEN_),
  ParKeyWord("EXTERNAL",           TOK_EXTERNAL,    ANS_|RESWORD_),
  ParKeyWord("EXTERNALTOLOB",      TOK_EXTERNALTOLOB,   NONRESTOKEN_),
  ParKeyWord("EXTERNALTOSTRING",      TOK_EXTERNALTOSTRING,   NONRESTOKEN_),
  ParKeyWord("EXTRACT",            TOK_EXTRACT,     ANS_|RESWORD_),
  ParKeyWord("EXTRACT_SOURCE",     TOK_EXTRACT_SOURCE, NONRESTOKEN_),
  ParKeyWord("EXTRACT_TARGET",     TOK_EXTRACT_TARGET, NONRESTOKEN_),
  ParKeyWord("FALLBACK",           TOK_FALLBACK,    NONRESTOKEN_),
  ParKeyWord("FALSE",              TOK_FALSE,       ANS_|RESWORD_),
  ParKeyWord("FAMILY",               TOK_FAMILY,        NONRESTOKEN_),
  ParKeyWord("FAST",               TOK_FAST,        NONRESTOKEN_),
  ParKeyWord("FEATURE_VERSION_INFO",TOK_FEATURE_VERSION_INFO, NONRESTOKEN_),
  ParKeyWord("FETCH",              TOK_FETCH,       ANS_|RESWORD_),
  ParKeyWord("FILE",               TOK_FILE,        NONRESTOKEN_),
  ParKeyWord("FILETOLOB",          TOK_FILETOLOB,   NONRESTOKEN_),
  ParKeyWord("FILETOEXTERNAL",          TOK_FILETOEXTERNAL,   NONRESTOKEN_),
  ParKeyWord("FINAL",              TOK_FINAL,       NONRESTOKEN_),
  ParKeyWord("FIRST",              TOK_FIRST,       SECOND_|ANS_|RESWORD_),
  ParKeyWord("FIRSTDAYOFYEAR",     TOK_FIRSTDAYOFYEAR, NONRESTOKEN_),
  ParKeyWord("FIRST_FSCODE",       TOK_FIRST_FSCODE, NONRESTOKEN_),
  ParKeyWord("FIXED",              TOK_FIXED,        NONRESTOKEN_),
  ParKeyWord("FLOAT",              TOK_FLOAT,       ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("FLOAT_IEEE",         TOK_FLOAT_IEEE,  NONRESTOKEN_),
  ParKeyWord("FLOOR",              TOK_FLOOR,       NONRESTOKEN_),
  ParKeyWord("FN",                 TOK_FN,          NONRESTOKEN_),
  ParKeyWord("FOLLOWING",          TOK_FOLLOWING,   NONRESTOKEN_),
  ParKeyWord("FOR",                TOK_FOR,         FIRST_|ANS_|RESWORD_),
  ParKeyWord("FORCE",              TOK_FORCE,       NONRESTOKEN_),
  ParKeyWord("FOREIGN",            TOK_FOREIGN,     ANS_|RESWORD_),
  ParKeyWord("FORMAT",             TOK_FORMAT,      NONRESTOKEN_),
  ParKeyWord("FOUND",              TOK_FOUND,       ANS_|RESWORD_),
  ParKeyWord("FRACTION",           TOK_FRACTION,    COMPAQ_|RESWORD_),
  ParKeyWord("FREE",               TOK_FREE,        COMPAQ_|RESWORD_),
  ParKeyWord("FREESPACE",          TOK_FREESPACE,   NONRESTOKEN_),  
  ParKeyWord("FROM",               TOK_FROM,        ANS_|RESWORD_),
  ParKeyWord("FULL",               TOK_FULL,        ANS_|RESWORD_),
  ParKeyWord("FUNCTION",           TOK_FUNCTION,    COMPAQ_|RESWORD_),
  ParKeyWord("FUNCTIONS",          TOK_FUNCTIONS,   NONRESTOKEN_),
  ParKeyWord("G",                  TOK_G,           NONRESTOKEN_),
  ParKeyWord("GENERAL",            IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("GENERATE",           TOK_GENERATE,    NONRESTOKEN_),
  ParKeyWord("GENERATED",          TOK_GENERATED,    NONRESTOKEN_),
  ParKeyWord("GET",                TOK_GET,         ANS_|RESWORD_),
  ParKeyWord("GHOST",              TOK_GHOST,       NONRESTOKEN_),
  ParKeyWord("GIVE",               TOK_GIVE,        NONRESTOKEN_),
  ParKeyWord("GLOBAL",             TOK_GLOBAL,      ANS_|RESWORD_),
  ParKeyWord("GO",                 TOK_GO,          FIRST_|ANS_|RESWORD_),
  ParKeyWord("GOTO",               TOK_GOTO,        FIRST_|ANS_|RESWORD_),
  ParKeyWord("GRANT",              TOK_GRANT,       ANS_|RESWORD_),
  ParKeyWord("GRANTEES",           TOK_GRANTEES,    NONRESTOKEN_),
  ParKeyWord("GRANTED",            TOK_GRANTED,     NONRESTOKEN_),
  ParKeyWord("GREATEST",                  TOK_GREATEST,           NONRESTOKEN_),
  ParKeyWord("GROUP",              TOK_GROUP,       ANS_|RESWORD_),
  ParKeyWord("GROUP_CONCAT",       TOK_GROUP_CONCAT,   NONRESTOKEN_),
  ParKeyWord("GROUPING",           TOK_GROUPING,    COMPAQ_|RESWORD_),
  ParKeyWord("GROUPING_ID",        TOK_GROUPING_ID, NONRESTOKEN_),
  ParKeyWord("GZIP",               TOK_GZIP,         NONRESTOKEN_),
  ParKeyWord("HARDWARE",           TOK_HARDWARE,    NONRESTOKEN_),
  ParKeyWord("HASH",               TOK_HASH,        NONRESTOKEN_),
  ParKeyWord("HASH2",              TOK_HASH2,        NONRESTOKEN_),
  ParKeyWord("HASHPARTFUNC",       TOK_HASHPARTFUNC, NONRESTOKEN_),
  ParKeyWord("HASH2PARTFUNC",      TOK_HASH2PARTFUNC, NONRESTOKEN_),
  ParKeyWord("HAVING",             TOK_HAVING,      ANS_|RESWORD_),
  ParKeyWord("HBASE",              TOK_HBASE,      NONRESTOKEN_),
  ParKeyWord("HBASE_OPTIONS",  TOK_HBASE_OPTIONS,      NONRESTOKEN_),
  ParKeyWord("HBASE_TIMESTAMP",  TOK_HBASE_TIMESTAMP,      NONRESTOKEN_),
  ParKeyWord("HBASE_VERSION",  TOK_HBASE_VERSION,      NONRESTOKEN_),
  ParKeyWord("HBMAP_TABLE",    TOK_HBMAP_TABLE, NONRESTOKEN_),
  ParKeyWord("HEADER",             TOK_HEADER,      NONRESTOKEN_),
  ParKeyWord("HEADING",            TOK_HEADING,     NONRESTOKEN_),
  ParKeyWord("HEADINGS",           TOK_HEADINGS,    NONRESTOKEN_),
  ParKeyWord("HEX",                TOK_HEX,         NONRESTOKEN_),
  ParKeyWord("HEXADECIMAL",        TOK_HEXADECIMAL, NONRESTOKEN_),
  ParKeyWord("HIGH_VALUE",         TOK_HIGH_VALUE,  NONRESTOKEN_),
  ParKeyWord("HIVE",               TOK_HIVE,  NONRESTOKEN_),
  ParKeyWord("HIVEMD",                    TOK_HIVEMD,  NONRESTOKEN_),
  ParKeyWord("HOLD",               TOK_HOLD,        THIRD_|NONRESTOKEN_),
  ParKeyWord("HORIZONTAL",         TOK_HORIZONTAL,  NONRESTOKEN_),
  ParKeyWord("HOST",               TOK_HOST,        COMPAQ_|RESWORD_),
  ParKeyWord("HOUR",               TOK_HOUR,        ANS_|RESWORD_),
  ParKeyWord("HOURS",              TOK_HOURS,       NONRESTOKEN_),
  ParKeyWord("ICOMPRESS",          TOK_ICOMPRESS,   NONRESTOKEN_),
  ParKeyWord("IDENTITY",           TOK_IDENTITY,    ANS_|RESWORD_),
  ParKeyWord("IF",                 TOK_IF,          POTANS_|RESWORD_),
  ParKeyWord("IFNULL",             TOK_NVL,         NONRESTOKEN_),
  ParKeyWord("IGNORE",             TOK_IGNORE,      POTANS_|RESWORD_),
  ParKeyWord("IGNORETRIGGERS",     TOK_IGNORETRIGGERS, FLAGSNONE_),
  ParKeyWord("IGNORE_TRIGGER",     TOK_IGNORE_TRIGGER, NONRESTOKEN_),
  ParKeyWord("IMMEDIATE",          TOK_IMMEDIATE,   ANS_|RESWORD_),
  ParKeyWord("IMMUTABLE",          TOK_IMMUTABLE,   NONRESTOKEN_),
  ParKeyWord("IMPLICIT",           TOK_IMPLICIT,    NONRESTOKEN_),
  ParKeyWord("IN",                 TOK_IN,          SECOND_|ANS_|RESWORD_),
  ParKeyWord("INCLUSIVE",          TOK_INCLUSIVE,   NONRESTOKEN_),
  ParKeyWord("INCREMENT",          TOK_INCREMENT,    NONRESTOKEN_),
  ParKeyWord("INCREMENTAL",        TOK_INCREMENTAL,  NONRESTOKEN_),
  ParKeyWord("INDEX",              TOK_INDEX,       SECOND_|NONRESTOKEN_),
  ParKeyWord("INDEXES",            TOK_INDEXES,     NONRESTOKEN_),
  ParKeyWord("INDEX_TABLE",        TOK_INDEX_TABLE, NONRESTOKEN_),
  ParKeyWord("INDICATOR",          TOK_INDICATOR,   ANS_|RESWORD_),
  ParKeyWord("INDICATOR_DATA",     TOK_INDICATOR_DATA, NONRESTOKEN_),
  ParKeyWord("INDICATOR_POINTER",  TOK_INDICATOR_POINTER, NONRESTOKEN_),
  ParKeyWord("INDICATOR_TYPE",     TOK_INDICATOR_TYPE, NONRESTOKEN_),
  ParKeyWord("INET_ATON",          TOK_INET_ATON, NONRESTOKEN_),
  ParKeyWord("INET_NTOA",          TOK_INET_NTOA, NONRESTOKEN_),
  ParKeyWord("INITIAL",            TOK_INITIAL,       NONRESTOKEN_),
  ParKeyWord("INITIALIZATION",     TOK_INITIALIZATION, FLAGSNONE_),
  ParKeyWord("INITIALIZE",         TOK_INITIALIZE,  FIRST_|NONRESTOKEN_),
  ParKeyWord("INITIALIZED",        TOK_INITIALIZED, FLAGSNONE_),
  ParKeyWord("INITIALLY",          IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("INGEST",             TOK_INGEST,      NONRESTOKEN_),
  ParKeyWord("INNER",              TOK_INNER,       ANS_|RESWORD_),
  ParKeyWord("INOUT",              TOK_INOUT,       COMPAQ_|RESWORD_),
  ParKeyWord("INPUT",              TOK_INPUT,       ANS_|RESWORD_),
  ParKeyWord("INPUTS",             TOK_INPUTS,      NONRESTOKEN_),
  ParKeyWord("INSENSITIVE",        IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("INSERT",             TOK_INSERT,      ANS_|RESWORD_),
  ParKeyWord("INSERT_ONLY",        TOK_INSERT_ONLY, NONRESTOKEN_),
  ParKeyWord("INS",                TOK_INS,         NONRESTOKEN_),
  ParKeyWord("INSERTLOG",          TOK_INSERTLOG,   FLAGSNONE_),
  ParKeyWord("INSTR",              TOK_INSTR,       NONRESTOKEN_),
  ParKeyWord("INT",                TOK_INTEGER,     ANS_|RESWORD_),
  ParKeyWord("INTEGER",            TOK_INTEGER,     ANS_|RESWORD_),
  ParKeyWord("INTERNAL",           TOK_INTERNAL,    FLAGSNONE_),
  ParKeyWord("INTERSECT",          TOK_INTERSECT,   ANS_|RESWORD_),
  ParKeyWord("INTERVAL",           TOK_INTERVAL,    ANS_|RESWORD_),
  ParKeyWord("INTERVALS",          TOK_INTERVALS,   NONRESTOKEN_),
  ParKeyWord("INTO",               TOK_INTO,        ANS_|RESWORD_),
  ParKeyWord("INVOKE",             TOK_INVOKE,      NONRESTOKEN_),
  ParKeyWord("INVOKER",            TOK_INVOKER,     NONRESTOKEN_),
  ParKeyWord("IO",                 TOK_IO,          NONRESTOKEN_),
  ParKeyWord("IS",                 TOK_IS,          ANS_|RESWORD_),
  ParKeyWord("ISLACK",             TOK_ISLACK,      NONRESTOKEN_),
  ParKeyWord("ISNULL",             TOK_ISNULL,      NONRESTOKEN_),
  ParKeyWord("ISOLATE",            TOK_ISOLATE,     NONRESTOKEN_),
  ParKeyWord("ISOLATION",          TOK_ISOLATION,   ANS_|RESWORD_),
  ParKeyWord("IS_IPV4",            TOK_ISIPV4,      NONRESTOKEN_),
  ParKeyWord("IS_IPV6",            TOK_ISIPV6,      NONRESTOKEN_),
  ParKeyWord("ITERATE",            TOK_ITERATE,     COMPAQ_|RESWORD_),
  ParKeyWord("IUDLOG",             TOK_IUDLOG,      FLAGSNONE_),
  ParKeyWord("IUD_LOG_TABLE",      TOK_IUD_LOG_TABLE, FLAGSNONE_),
  ParKeyWord("INVALID", 	   TOK_INVALID,    NONRESTOKEN_),
  ParKeyWord("INVALIDATE", 	   TOK_INVALIDATE, NONRESTOKEN_),
  ParKeyWord("JAVA",               TOK_JAVA,        NONRESTOKEN_),
  ParKeyWord("JOIN",               TOK_JOIN,        SECOND_|ANS_|RESWORD_),
  ParKeyWord("JOURNAL",            TOK_JOURNAL,     NONRESTOKEN_), 
  ParKeyWord("JSON_OBJECT_FIELD_TEXT",  TOK_JSONOBJECTFIELDTEXT, NONRESTOKEN_),
  ParKeyWord("JULIANTIMESTAMP",    TOK_JULIANTIMESTAMP, NONRESTOKEN_),
  ParKeyWord("K",                  TOK_K,           NONRESTOKEN_),
  ParKeyWord("KEY",                TOK_KEY,         ANS_|RESWORD_),
  ParKeyWord("KEY_RANGE_COMPARE",  TOK_KEY_RANGE_COMPARE, NONRESTOKEN_),
  ParKeyWord("LABEL",              TOK_LABEL,       NONRESTOKEN_),
  ParKeyWord("LABEL_ALTER",        TOK_LABEL_ALTER,        NONRESTOKEN_),
  ParKeyWord("LABEL_CREATE",       TOK_LABEL_CREATE,       NONRESTOKEN_),
  ParKeyWord("LABEL_DROP",         TOK_LABEL_DROP,         NONRESTOKEN_),
  ParKeyWord("LABEL_PURGEDATA",    TOK_LABEL_PURGEDATA,    NONRESTOKEN_),
  ParKeyWord("LAG",               TOK_LAG,        ANS_|RESWORD_),  
  ParKeyWord("LANGUAGE",           TOK_LANGUAGE,    ANS_|RESWORD_),
  ParKeyWord("LARGE",              TOK_LARGE,       COMPAQ_|RESWORD_),
  ParKeyWord("LARGEINT",           TOK_LARGEINT,    NONRESTOKEN_),
  ParKeyWord("LAST",               TOK_LAST,        ANS_|RESWORD_),
  ParKeyWord("LASTNOTNULL",        TOK_LASTNOTNULL, NONRESTOKEN_),
  ParKeyWord("LASTSYSKEY",         TOK_LASTSYSKEY,  NONRESTOKEN_),
  ParKeyWord("LAST_DAY",           TOK_LAST_DAY,    NONRESTOKEN_),
  ParKeyWord("LAST_FSCODE",        TOK_LAST_FSCODE, NONRESTOKEN_),
  ParKeyWord("LAST_SYSKEY",        TOK_LAST_SYSKEY, NONRESTOKEN_),
  ParKeyWord("LATERAL",            TOK_LATERAL,     COMPAQ_|RESWORD_),
  ParKeyWord("LCASE",              TOK_LCASE,       NONRESTOKEN_),
  ParKeyWord("LEAD",               TOK_LEAD,        ANS_|RESWORD_),
  ParKeyWord("LEADING",            TOK_LEADING,     ANS_|RESWORD_),
  ParKeyWord("LEADING_PRECISION",  TOK_LEADING_PRECISION, NONRESTOKEN_),
  ParKeyWord("LEAST",                  TOK_LEAST,           NONRESTOKEN_),
  ParKeyWord("LEAVE",              IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("LEFT",               TOK_LEFT,        ANS_|RESWORD_),
  ParKeyWord("LENGTH",             TOK_LENGTH,      NONRESTOKEN_),
  ParKeyWord("LESS",               IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("LEVEL",              TOK_LEVEL,       ANS_|RESWORD_),
  ParKeyWord("LEVELS",             TOK_LEVELS,      NONRESTOKEN_),
  ParKeyWord("LIBRARY",            TOK_LIBRARY,     NONRESTOKEN_|SECOND_),
  ParKeyWord("LIBRARIES",          TOK_LIBRARIES,   NONRESTOKEN_),
  ParKeyWord("LIKE",               TOK_LIKE,        ANS_|RESWORD_),
  ParKeyWord("LIMIT",              TOK_LIMIT,      POTANS_|RESWORD_),
  ParKeyWord("LINE_NUMBER",        TOK_LINE_NUMBER, NONRESTOKEN_),
  ParKeyWord("LOAD",               TOK_LOAD,        NONRESTOKEN_|SECOND_),
  ParKeyWord("LOADTOLOB",          TOK_LOADTOLOB,   NONRESTOKEN_),
  ParKeyWord("LOAD_ID",            TOK_LOAD_ID,     NONRESTOKEN_),
  ParKeyWord("LOB",                TOK_LOB,         NONRESTOKEN_|SECOND_),
  ParKeyWord("LOBLENGTH",          TOK_LOBLENGTH,   NONRESTOKEN_),
  ParKeyWord("LOBTOBUFFER",        TOK_LOBTOBUFFER, NONRESTOKEN_),
  ParKeyWord("LOBTOFILE",          TOK_LOBTOFILE, NONRESTOKEN_),
  ParKeyWord("LOBTOSTRING",        TOK_LOBTOSTRING, NONRESTOKEN_),
  ParKeyWord("EMPTY_BLOB",         TOK_EMPTY_BLOB, NONRESTOKEN_),
  ParKeyWord("EMPTY_CLOB",         TOK_EMPTY_CLOB, NONRESTOKEN_),
  ParKeyWord("LOCAL",              TOK_LOCAL,       ANS_|RESWORD_),
  ParKeyWord("LOCALTIME",          TOK_LOCALTIME,   COMPAQ_|RESWORD_),
  ParKeyWord("LOCALTIMESTAMP",     TOK_LOCALTIMESTAMP, COMPAQ_|RESWORD_),
  ParKeyWord("LOCATE",             TOK_LOCATE,      NONRESTOKEN_),
  ParKeyWord("LOCATION",           TOK_LOCATION,    NONRESTOKEN_),
  ParKeyWord("LOCATOR",            TOK_LOCATOR,     COMPAQ_|RESWORD_),
  ParKeyWord("LOCK",               TOK_LOCK,        FIRST_|NONRESTOKEN_),
  ParKeyWord("LOCKING",            TOK_LOCKING,     NONRESTOKEN_),
  ParKeyWord("LOCKONREFRESH",      TOK_LOCKONREFRESH, FLAGSNONE_),
  ParKeyWord("LOG",                TOK_LOG,         NONRESTOKEN_),
  ParKeyWord("LOG10",              TOK_LOG10,       NONRESTOKEN_),
  ParKeyWord("LOG2",               TOK_LOG2,       NONRESTOKEN_),
  ParKeyWord("LOGGABLE",           TOK_LOGGABLE,    FLAGSNONE_),
  ParKeyWord("LOGON",              TOK_LOGON,       NONRESTOKEN_),
  ParKeyWord("LONG",               TOK_LONG,        NONRESTOKEN_),
  ParKeyWord("LONGWVARCHAR",       TOK_LONGWVARCHAR,NONRESTOKEN_),
  ParKeyWord("LOOP",               IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("LOWER",              TOK_LOWER,       ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("LOW_VALUE",          TOK_LOW_VALUE,   NONRESTOKEN_),
  ParKeyWord("LPAD",               TOK_LPAD,        NONRESTOKEN_),
  ParKeyWord("LSDEC",              TOK_LSDECIMAL,   NONRESTOKEN_),
  ParKeyWord("LSDECIMAL",          TOK_LSDECIMAL,   NONRESTOKEN_),
  ParKeyWord("LTRIM",              TOK_LTRIM,       NONRESTOKEN_),
  ParKeyWord("LZO",                TOK_LZO,         NONRESTOKEN_),
  ParKeyWord("M",                  TOK_M,           NONRESTOKEN_),
  ParKeyWord("MAINTAIN",           TOK_MAINTAIN,    SECOND_|COMPAQ_|RESWORD_),
  ParKeyWord("MANAGEMENT",         TOK_MANAGEMENT,  NONRESTOKEN_),
  ParKeyWord("MANUAL",             TOK_MANUAL,      FLAGSNONE_),
  ParKeyWord("MAP",                TOK_MAP,         NONRESTOKEN_),
  ParKeyWord("MASTER",             TOK_MASTER,      NONRESTOKEN_),
  ParKeyWord("MATCH",              TOK_MATCH,       ANS_|RESWORD_),
  ParKeyWord("MATCHED",            TOK_MATCHED,     ANS_|RESWORD_),
  ParKeyWord("MATERIALIZED",       TOK_MATERIALIZED,FLAGSNONE_),
  ParKeyWord("MAX",                TOK_MAX,         ANS_|RESWORD_),
  ParKeyWord("MAXEXTENTS",         TOK_MAXEXTENTS,  NONRESTOKEN_),
  ParKeyWord("MAXIMUM",            TOK_MAX,         NONRESTOKEN_),
  ParKeyWord("MAXRUNTIME",         TOK_MAXRUNTIME,  SECOND_|NONRESTOKEN_),
  ParKeyWord("MAXVALUE",           TOK_MAXVALUE,    NONRESTOKEN_),
  ParKeyWord("MD5",                TOK_MD5,         NONRESTOKEN_),
  ParKeyWord("MEMORY",             TOK_MEMORY,      NONRESTOKEN_),
  ParKeyWord("MERGE",              TOK_MERGE,       ANS_|RESWORD_),
  ParKeyWord("MESSAGE",            TOK_MESSAGE,     NONRESTOKEN_),
  ParKeyWord("MESSAGE_LENGTH",     TOK_MESSAGE_LEN, NONRESTOKEN_),
  ParKeyWord("MESSAGE_OCTET_LENGTH", TOK_MESSAGE_OCTET_LEN, NONRESTOKEN_),
  ParKeyWord("MESSAGE_TEXT",       TOK_MESSAGE_TEXT, NONRESTOKEN_),
  ParKeyWord("METADATA",       TOK_METADATA, SECOND_ | NONRESTOKEN_),
  ParKeyWord("MIN",                TOK_MIN,         ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("MINIMAL",            TOK_MINIMAL,     NONRESTOKEN_),
  ParKeyWord("MINUTE",             TOK_MINUTE,      ANS_|RESWORD_),
  ParKeyWord("MINUTES",            TOK_MINUTES,     NONRESTOKEN_),
  ParKeyWord("MINVALUE",           TOK_MINVALUE,   NONRESTOKEN_),
  ParKeyWord("MIXED",              TOK_MIXED,       FLAGSNONE_),
  ParKeyWord("MOD",                TOK_MOD,         NONRESTOKEN_),
  ParKeyWord("MODE",               TOK_MODE,        NONRESTOKEN_),
  ParKeyWord("MODIFIES",           TOK_MODIFIES,    COMPAQ_|RESWORD_),
  ParKeyWord("MODIFY",             IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("MODULE",             TOK_MODULE,      ANS_|RESWORD_),
  ParKeyWord("MODULES",            TOK_MODULES,     NONRESTOKEN_),
  ParKeyWord("MONTH",              TOK_MONTH,       ANS_|RESWORD_),
  ParKeyWord("MONTHNAME",          TOK_MONTHNAME,   NONRESTOKEN_),
  ParKeyWord("MONTHS_BETWEEN",     TOK_MONTHS_BETWEEN,   NONRESTOKEN_),
  ParKeyWord("MORE",               TOK_MORE,        NONRESTOKEN_),
  ParKeyWord("MOVE",               TOK_MOVE,        NONRESTOKEN_),
  ParKeyWord("MOVEMENT",           TOK_MOVEMENT,    NONRESTOKEN_),
  ParKeyWord("MOVINGAVG",          TOK_MAVG,        NONRESTOKEN_),
  ParKeyWord("MOVINGCOUNT",        TOK_MCOUNT,      NONRESTOKEN_),
  ParKeyWord("MOVINGMAX",          TOK_MMAX,        NONRESTOKEN_),
  ParKeyWord("MOVINGMIN",          TOK_MMIN,        NONRESTOKEN_),
  ParKeyWord("MOVINGRANK",         TOK_MRANK,       NONRESTOKEN_),
  ParKeyWord("MSCK",               TOK_MSCK,        NONRESTOKEN_),
  ParKeyWord("MOVINGSTDDEV",       TOK_MSTDDEV,     NONRESTOKEN_),
  ParKeyWord("MOVINGSUM",          TOK_MSUM,        NONRESTOKEN_),
  ParKeyWord("MOVINGVARIANCE",     TOK_MVARIANCE,   NONRESTOKEN_),
  ParKeyWord("MTS",                TOK_MTS,         NONRESTOKEN_),
  ParKeyWord("MULTI",              TOK_MULTI,       NONRESTOKEN_),
  ParKeyWord("MULTIDELTA",         TOK_MULTIDELTA,  FLAGSNONE_),
  ParKeyWord("MULTISET",           TOK_MULTISET,    NONRESTOKEN_),
  ParKeyWord("MV",                 TOK_MV,          FLAGSNONE_),
  ParKeyWord("MVATTRIBUTE",        TOK_MVATTRIBUTE, FLAGSNONE_),
  ParKeyWord("MVATTRIBUTES",       TOK_MVATTRIBUTES,FLAGSNONE_),
  ParKeyWord("MVGROUP",            TOK_MVGROUP,     FLAGSNONE_),
  ParKeyWord("MVGROUPS",           TOK_MVGROUPS,    FLAGSNONE_),
  ParKeyWord("MVLOG",              TOK_MVLOG,       FLAGSNONE_),
  ParKeyWord("MVS",                TOK_MVS,         FLAGSNONE_),
  ParKeyWord("MVSTATUS",           TOK_MVSTATUS,    FLAGSNONE_),
  ParKeyWord("MVSUMD",             TOK_MVS_UMD,     FLAGSNONE_),
  ParKeyWord("MVUID",              TOK_MVUID,       FLAGSNONE_),
  ParKeyWord("MV_TABLE",           TOK_MV_TABLE,    FLAGSNONE_),
  ParKeyWord("NAME",               TOK_NAME,        NONRESTOKEN_),
  ParKeyWord("NAMED",              TOK_NAMED,       NONRESTOKEN_),
  ParKeyWord("NAMES",              TOK_NAMES,       ANS_|RESWORD_),
  ParKeyWord("NAMESPACE",          TOK_NAMESPACE,   NONRESTOKEN_),
  ParKeyWord("NAMETYPE",           TOK_NAMETYPE,    NONRESTOKEN_),
  ParKeyWord("NATIONAL",           TOK_NATIONAL,    ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("NATIVE",             TOK_NATIVE,      NONRESTOKEN_),
  ParKeyWord("NATURAL",            TOK_NATURAL,     ANS_|RESWORD_),
  ParKeyWord("NCHAR",              TOK_NCHAR,       ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("NCLOB",              TOK_NCLOB,       COMPAQ_|RESWORD_),
  ParKeyWord("NECESSARY",          TOK_NECESSARY,   NONRESTOKEN_),
  ParKeyWord("NEEDED",             TOK_NEEDED,      NONRESTOKEN_),
  ParKeyWord("NEW",                TOK_NEW,         ANS_|RESWORD_|NONRESTOKEN_|ALLOWOLDNEW_),
  ParKeyWord("NEXT",               TOK_NEXT,        ANS_|RESWORD_),
  ParKeyWord("NEXT_DAY",           TOK_NEXT_DAY,    NONRESTOKEN_),
  ParKeyWord("NO",                 TOK_NO,          FIRST_|ANS_|RESWORD_),
  ParKeyWord("NODELETE",           TOK_NODELETE,    FLAGSNONE_),
  ParKeyWord("NODES",              TOK_NODES,       NONRESTOKEN_),
  ParKeyWord("NOLOG",              TOK_NOLOG,       NONRESTOKEN_),
  ParKeyWord("NOMVLOG",            TOK_NOMVLOG,     FLAGSNONE_),
  ParKeyWord("NONE",               TOK_NONE,        ANS_|RESWORD_),
  ParKeyWord("NORMAL",             TOK_NORMAL,      NONRESTOKEN_),
  ParKeyWord("NOT",                TOK_NOT,         FIRST_|ANS_|RESWORD_),
  ParKeyWord("NOW",                TOK_NOW,         NONRESTOKEN_),
  ParKeyWord("NSK_CODE",           TOK_NSK_CODE,    NONRESTOKEN_),
  ParKeyWord("NULL",               TOK_NULL,        ANS_|RESWORD_),
  ParKeyWord("NULLABLE",           TOK_NULLABLE,    NONRESTOKEN_),
  ParKeyWord("NULLIF",             TOK_NULLIF,      ANS_|RESWORD_),
  ParKeyWord("NULLIFZERO",         TOK_NULLIFZERO,  NONRESTOKEN_),
  ParKeyWord("NULL_IND_OFFSET",    TOK_NULL_IND_OFFSET, NONRESTOKEN_),
  ParKeyWord("NULL_STRING",        TOK_NULL_STRING, NONRESTOKEN_),
  ParKeyWord("NUMBER",             TOK_NUMBER,      NONRESTOKEN_),
  ParKeyWord("NUMERIC",            TOK_NUMERIC,     ANS_|RESWORD_),
  ParKeyWord("NUM_OF_RANGES",      TOK_NUM_OF_RANGES, FLAGSNONE_),
  ParKeyWord("NVL",                TOK_NVL,         NONRESTOKEN_),
  ParKeyWord("OBJECT",            TOK_OBJECT,     NONRESTOKEN_),
  ParKeyWord("OBJECTS",            TOK_OBJECTS,     NONRESTOKEN_),
  ParKeyWord("OBSOLETE",           TOK_OBSOLETE,    NONRESTOKEN_),
  ParKeyWord("OCTET_LENGTH",       TOK_OCTET_LENGTH, ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("OF",                 TOK_OF,          ANS_|RESWORD_),
  ParKeyWord("OFF",                TOK_OFF,         POTANS_|RESWORD_),
  ParKeyWord("OFFLINE",            TOK_OFFLINE,     NONRESTOKEN_),
  ParKeyWord("OFFSET",             TOK_OFFSET,      NONRESTOKEN_),
  ParKeyWord("OJ",                 TOK_OJ,          NONRESTOKEN_),
  ParKeyWord("OLD",                TOK_OLD,         ANS_|RESWORD_|NONRESTOKEN_|ALLOWOLDNEW_),
  ParKeyWord("ON",                 TOK_ON,          FIRST_|ANS_|RESWORD_),
  ParKeyWord("ONLINE",             TOK_ONLINE,      NONRESTOKEN_),
  ParKeyWord("ONLY",               TOK_ONLY,        THIRD_|ANS_|RESWORD_),
  ParKeyWord("OPCODE",             TOK_OPCODE,      NONRESTOKEN_),
  ParKeyWord("OPEN",               TOK_OPEN,        ANS_|RESWORD_),
  ParKeyWord("OPENBLOWNAWAY",      TOK_OPENBLOWNAWAY, FLAGSNONE_),
  ParKeyWord("OPERATION",          IDENTIFIER,      POTANS_|NONRESWORD_),
  // The word OPERATION is used as a column in the SMD LOCKS table, so
  // we have not made this word reserved even though it is in the
  // potential ANSI reserved word list.

  ParKeyWord("OPERATORS",          IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("OPTION",             TOK_OPTION,      ANS_|RESWORD_),
  ParKeyWord("OPTIONS",            TOK_OPTIONS,     COMPAQ_|RESWORD_),
  ParKeyWord("OR",                 TOK_OR,          ANS_|RESWORD_),
  ParKeyWord("ORDER",              TOK_ORDER,       ANS_|RESWORD_),
  ParKeyWord("ORDERED",            TOK_ORDERED,     NONRESTOKEN_),
  ParKeyWord("ORDINALITY",         TOK_ORDINALITY,  COMPAQ_|RESWORD_),
  ParKeyWord("OSIM",                 TOK_OSIM,    NONRESTOKEN_),
  ParKeyWord("OS_USERID",          TOK_OS_USERID,   NONRESTOKEN_),
  ParKeyWord("OTHERS",             IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("OUT",                TOK_OUT,         COMPAQ_|RESWORD_),
  ParKeyWord("OUTER",              TOK_OUTER,       ANS_|RESWORD_),
  ParKeyWord("OUTPUT",             TOK_OUTPUT,      ANS_|RESWORD_),
  ParKeyWord("OVER",               TOK_OVER,        NONRESTOKEN_),
  ParKeyWord("OVERLAPS",           TOK_OVERLAPS,    ANS_|RESWORD_),
  ParKeyWord("OVERRIDE",           TOK_OVERRIDE,    NONRESTOKEN_),
  ParKeyWord("OVERWRITE",          TOK_OVERWRITE,    NONRESTOKEN_),
  ParKeyWord("PACKED",             TOK_PACKED,      NONRESTOKEN_),
  ParKeyWord("PAD",                IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("PAGE",               TOK_PAGE,        NONRESTOKEN_),
  ParKeyWord("PAGES",              TOK_PAGES,       NONRESTOKEN_),
  ParKeyWord("PARALLEL",           TOK_PARALLEL,    NONRESTOKEN_),
  ParKeyWord("PARALLELISM",        TOK_PARALLELISM, NONRESTOKEN_),
  ParKeyWord("PARAMETER",          TOK_PARAMETER,   COMPAQ_|RESWORD_),
  ParKeyWord("PARAMETERS",         IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("PARAMETER_INDEX",    TOK_PARAMETER_INDEX,NONRESTOKEN_),
  ParKeyWord("PARAMETER_MODE",     TOK_PARAMETER_MODE,NONRESTOKEN_),
  ParKeyWord("PARAMETER_ORDINAL_POSITION",TOK_PARAMETER_ORDINAL_POSITION,
                                                    NONRESTOKEN_),
  ParKeyWord("PARENT",             TOK_PARENT,      NONRESTOKEN_),
  ParKeyWord("PARSERFLAGS",        TOK_PARSERFLAGS, NONRESTOKEN_),
  ParKeyWord("PARTIAL",            TOK_PARTIAL,     ANS_|RESWORD_),
  ParKeyWord("PARTITION",          TOK_PARTITION,   FIRST_|SECOND_|NONRESTOKEN_),
  ParKeyWord("PARTITIONING",       TOK_PARTITIONING, NONRESTOKEN_),
  ParKeyWord("PARTITIONS",         TOK_PARTITIONS,  SECOND_|NONRESTOKEN_),
  ParKeyWord("PASS",               TOK_PASS,        NONRESTOKEN_),
  ParKeyWord("PATH",               TOK_PATH,        COMPAQ_|NONRESWORD_),
// PATH is already used in CQS ...
  ParKeyWord("PENDANT",            IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("PERCENT",            TOK_PERCENT,     NONRESTOKEN_),
  ParKeyWord("PERFORM",            TOK_PERFORM,     FIRST_|NONRESTOKEN_),
  ParKeyWord("PERIODIC",           TOK_PERIODIC,    SECOND_|NONRESTOKEN_),
  ParKeyWord("PERTABLE",           TOK_PERTABLE,    NONRESTOKEN_),
  ParKeyWord("PHASE",              TOK_PHASE,       FLAGSNONE_),
  ParKeyWord("PI",                 TOK_PI,          NONRESTOKEN_),
  ParKeyWord("PIC",                TOK_PICTURE,     FIRST_),
  ParKeyWord("PICTURE",            TOK_PICTURE,     FIRST_),
  ParKeyWord("PIPELINE",           TOK_PIPELINE,    FLAGSNONE_),
  ParKeyWord("PID",                TOK_PID,         NONRESTOKEN_),
  ParKeyWord("PIVOT_GROUP",                TOK_PIVOT_GROUP,         NONRESTOKEN_),
  ParKeyWord("PIVOT",                TOK_PIVOT,         NONRESTOKEN_),
  ParKeyWord("POOL",               TOK_POOL,        NONRESTOKEN_),
  ParKeyWord("POPULATE",           TOK_POPULATE,    NONRESTOKEN_),
  ParKeyWord("POSITION",           TOK_POSITION,    ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("POS",                TOK_POS,         NONRESTOKEN_),
  ParKeyWord("POSTFIX",            TOK_POSTFIX,     COMPAQ_|RESWORD_),
  ParKeyWord("POWER",              TOK_POWER,       NONRESTOKEN_),
  ParKeyWord("PRECEDING",          TOK_PRECEDING,   NONRESTOKEN_),
  ParKeyWord("PRECISION",          TOK_PRECISION,   ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("PREFER_FOR_SCAN_KEY", TOK_PREFER_FOR_SCAN_KEY, NONRESTOKEN_),
  //  ParKeyWord("PREFIX",             TOK_PREFIX,      COMPAQ_|RESWORD_),
  ParKeyWord("PREORDER",           IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("PREPARE",            TOK_PREPARE,     ANS_|RESWORD_),
  ParKeyWord("PRESERVE",           TOK_PRESERVE,    ANS_|RESWORD_),
  ParKeyWord("PRIMARY",            TOK_PRIMARY,     FIRST_|ANS_|RESWORD_),
  ParKeyWord("PRIOR",              IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("PRIORITY",           TOK_PRIORITY,    NONRESTOKEN_),
  ParKeyWord("PRIORITY_DELTA",     TOK_PRIORITY_DELTA,    NONRESTOKEN_),
  ParKeyWord("PRIVATE",            TOK_PRIVATE,     NONRESTOKEN_),
  ParKeyWord("PRIVILEGE",          TOK_PRIVILEGE,   NONRESWORD_),
  ParKeyWord("PRIVILEGES",         TOK_PRIVILEGES,  ANS_|RESWORD_),
  ParKeyWord("PROCEDURE",          TOK_PROCEDURE,   ANS_|RESWORD_),
  ParKeyWord("PROCEDURES",         TOK_PROCEDURES,  NONRESTOKEN_),
  ParKeyWord("PROCESS",            TOK_PROCESS,     NONRESTOKEN_),
  ParKeyWord("PROGRESS",           TOK_PROGRESS,    NONRESTOKEN_),
  ParKeyWord("PROMPT",             TOK_PROMPT,      NONRESTOKEN_),
  ParKeyWord("PROTECTED",          TOK_PROTECTED,   POTANS_|RESWORD_),
  ParKeyWord("PROTECTION",         TOK_PROTECTION,  NONRESTOKEN_),  
  ParKeyWord("PROTOTYPE",          TOK_PROTOTYPE,   COMPAQ_|RESWORD_),
  ParKeyWord("PUBLIC",             TOK_PUBLIC,      ANS_|RESWORD_),
  ParKeyWord("PURGEDATA",          TOK_PURGEDATA,   NONRESTOKEN_),
  ParKeyWord("QID",                TOK_QID,         NONRESTOKEN_),
  ParKeyWord("QID_INTERNAL",       TOK_QID_INTERNAL,  NONRESTOKEN_),
  ParKeyWord("QUARTER",            TOK_QUARTER,     NONRESTOKEN_),
  ParKeyWord("QUERY",              TOK_QUERY,       NONRESTOKEN_),
  ParKeyWord("QUERYCACHE",         TOK_QUERY_CACHE, NONRESTOKEN_),
  ParKeyWord("HYBRIDQUERYCACHE",         TOK_HYBRID_QUERY_CACHE, NONRESTOKEN_),
  ParKeyWord("HYBRIDQUERYCACHEENTRIES",     TOK_HYBRID_QUERY_CACHE_ENTRIES, NONRESTOKEN_),
  ParKeyWord("QUERYCACHEENTRIES",  TOK_QUERY_CACHE_ENTRIES, NONRESTOKEN_),
  ParKeyWord("CATMANCACHE",        TOK_CATMAN_CACHE, NONRESTOKEN_),
  ParKeyWord("NATABLECACHE",       TOK_NATABLE_CACHE, NONRESTOKEN_),
  ParKeyWord("NATABLECACHEENTRIES", TOK_NATABLE_CACHE_ENTRIES, NONRESTOKEN_),
  ParKeyWord("NAROUTINECACHE",     TOK_NAROUTINE_CACHE, NONRESTOKEN_),
  ParKeyWord("NAROUTINEACTIONCACHE",TOK_NAROUTINE_ACTION_CACHE, NONRESTOKEN_),
  ParKeyWord("QUALIFY",            TOK_QUALIFY,     CONDITIONAL_RES_ | RESWORD_),
  ParKeyWord("QUERYID_EXTRACT",    TOK_QUERYID_EXTRACT, NONRESTOKEN_),
  ParKeyWord("RADIANS",            TOK_RADIANS,     NONRESTOKEN_),
  ParKeyWord("RAND",               TOK_RAND,        NONRESTOKEN_),
  ParKeyWord("RANDOM",             TOK_RANDOM,      SECOND_|NONRESTOKEN_),
  ParKeyWord("RANGE",              TOK_RANGE,       NONRESTOKEN_),
  ParKeyWord("RANGE_N",            TOK_RANGE_N,     NONRESTOKEN_),
  ParKeyWord("RANGELOG",           TOK_RANGELOG,    FLAGSNONE_),
  ParKeyWord("RANGE_LOG_TABLE",    TOK_RANGE_LOG_TABLE, FLAGSNONE_),
  ParKeyWord("RANK",               TOK_RRANK,       NONRESTOKEN_),
  ParKeyWord("RATE",               TOK_RATE,        NONRESTOKEN_),
  ParKeyWord("READ",               TOK_READ,        SECOND_|ANS_|RESWORD_),
  ParKeyWord("READS",              TOK_READS,       COMPAQ_|RESWORD_),
  ParKeyWord("REAL",               TOK_REAL,        ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("REAL_IEEE",          TOK_REAL_IEEE,   NONRESTOKEN_),
  ParKeyWord("REBUILD",            TOK_REBUILD,     NONRESTOKEN_),
  ParKeyWord("RECOMPUTE",          TOK_RECOMPUTE,   FLAGSNONE_),
  ParKeyWord("RECORD_SEPARATOR",   TOK_RECORD_SEPARATOR, NONRESTOKEN_),
  ParKeyWord("RECOVER",            TOK_RECOVER,     NONRESTOKEN_),
  ParKeyWord("RECOVERY",           TOK_RECOVERY,    NONRESTOKEN_),
  ParKeyWord("RECURSIVE",          TOK_RECURSIVE,      POTANS_|RESWORD_),
  ParKeyWord("REDEFTIME",          TOK_REDEFTIME,   FLAGSNONE_),
  ParKeyWord("REF",                IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("REFERENCES",         TOK_REFERENCES,  ANS_|RESWORD_),
  ParKeyWord("REFERENCING",        TOK_REFERENCING, ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("REFRESH",            TOK_REFRESH,     FLAGSNONE_),
  ParKeyWord("REGEXP",             TOK_REGEXP,      NONRESTOKEN_),
  ParKeyWord("REGION",             TOK_REGION,      NONRESTOKEN_),
  ParKeyWord("REGISTER",           TOK_REGISTER,    NONRESTOKEN_),
  ParKeyWord("REGISTERED",         TOK_REGISTERED,  NONRESTOKEN_),
  ParKeyWord("REINITIALIZE",       TOK_REINITIALIZE, FIRST_|NONRESTOKEN_),
  ParKeyWord("RELATED",            TOK_RELATED,     NONRESTOKEN_),
  ParKeyWord("RELATEDNESS",        TOK_RELATEDNESS, NONRESTOKEN_),
  ParKeyWord("RELATIVE",           IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("RELOAD",             TOK_RELOAD,      NONRESTOKEN_),
  ParKeyWord("REMOTE",             TOK_REMOTE,      NONRESTOKEN_),
  ParKeyWord("REMOVE",             TOK_REMOVE,      FLAGSNONE_),
  ParKeyWord("RENAME",             TOK_RENAME,      NONRESTOKEN_),
  ParKeyWord("REPAIR",             TOK_REPAIR,      NONRESTOKEN_),
  ParKeyWord("REPEAT",             TOK_REPEAT,      NONRESTOKEN_),
  ParKeyWord("REPEATABLE",         TOK_REPEATABLE,  FIRST_|SECOND_|NONRESTOKEN_),
  ParKeyWord("REPLACE",            TOK_REPLACE,     POTANS_|RESWORD_),
  ParKeyWord("REPLICATE",          TOK_REPLICATE,   FIRST_|NONRESTOKEN_),
  ParKeyWord("REPOSITORY",         TOK_REPOSITORY,  NONRESTOKEN_),
  ParKeyWord("REQUEST",            TOK_REQUEST,     FLAGSNONE_),
  ParKeyWord("REQUIRED",           TOK_REQUIRED,    NONRESTOKEN_),
  ParKeyWord("RESET",              TOK_RESET,       NONRESTOKEN_),
  ParKeyWord("RESIGNAL",           IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("RESTORE",            TOK_RESTORE,     NONRESTOKEN_),
  ParKeyWord("RESTRICT",           TOK_RESTRICT,    ANS_|RESWORD_),
  ParKeyWord("RESULT",             TOK_RESULT,      COMPAQ_|RESWORD_),
  ParKeyWord("RESUME",             TOK_RESUME,      NONRESTOKEN_),
  ParKeyWord("RETRIES",            TOK_RETRIES,     NONRESTOKEN_),
  ParKeyWord("RETURN",             TOK_RETURN,      POTANS_|RESWORD_),
  ParKeyWord("RETURNED_LENGTH",    TOK_RETURNED_LENGTH, NONRESTOKEN_),
  ParKeyWord("RETURNED_OCTET_LENGTH", TOK_RETURNED_OCTET_LENGTH, NONRESTOKEN_),
  ParKeyWord("RETURNED_SQLSTATE",  TOK_RETURNED_SQLSTATE, NONRESTOKEN_),
  ParKeyWord("RETURNS",            TOK_RETURNS,     POTANS_|RESWORD_),
  ParKeyWord("REVERSE",            TOK_REVERSE,     NONRESTOKEN_),
  ParKeyWord("REVOKE",             TOK_REVOKE,      ANS_|RESWORD_),
  ParKeyWord("REWRITE",            TOK_REWRITE,     FLAGSNONE_),
  ParKeyWord("RIGHT",              TOK_RIGHT,       ANS_|RESWORD_),
  ParKeyWord("RMS",                TOK_RMS,         NONRESTOKEN_),
  ParKeyWord("ROLE",               TOK_ROLE,        NONRESTOKEN_|SECOND_), 
  ParKeyWord("ROLES",              TOK_ROLES,       NONRESTOKEN_),
  ParKeyWord("ROLLBACK",           TOK_ROLLBACK,    ANS_|RESWORD_),
  ParKeyWord("ROLLUP",             TOK_ROLLUP,      COMPAQ_|RESWORD_),
  ParKeyWord("ROUND",              TOK_ROUND,       NONRESTOKEN_),
  ParKeyWord("ROUNDROBINPARTFUNC", TOK_RRPARTFUNC,  NONRESTOKEN_),
  ParKeyWord("ROUTINE",            IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("ROW",                TOK_ROW,         ANS_|RESWORD_|SECOND_),
  ParKeyWord("ROWNUM",                TOK_ROWNUM,         NONRESTOKEN_),
  ParKeyWord("ROWS",               TOK_ROWS,        ANS_|RESWORD_),
  ParKeyWord("ROWSET",             TOK_ROWSET,      NONRESTOKEN_),
  ParKeyWord("ROWSET_IND_LAYOUT_SIZE",  TOK_ROWSET_IND_LAYOUT_SIZE, NONRESTOKEN_),
  ParKeyWord("ROWSET_SIZE",        TOK_ROWSET_SIZE, NONRESTOKEN_),
  ParKeyWord("ROWSET_VAR_LAYOUT_SIZE",  TOK_ROWSET_VAR_LAYOUT_SIZE, NONRESTOKEN_),
  ParKeyWord("ROWS_COVERED",       TOK_ROWS_COVERED,  FLAGSNONE_),
  ParKeyWord("ROWS_DELETED",       TOK_ROWS_DELETED,  FLAGSNONE_),
  ParKeyWord("ROWS_INSERTED",      TOK_ROWS_INSERTED, FLAGSNONE_),
  ParKeyWord("ROWS_UPDATED",       TOK_ROWS_UPDATED,  FLAGSNONE_),
  ParKeyWord("ROWWISE",            TOK_ROWWISE,     NONRESTOKEN_),
  ParKeyWord("ROW_COUNT",          TOK_ROW_COUNT,   NONRESTOKEN_),
  ParKeyWord("ROW_NUMBER",         TOK_ROW_NUMBER,  NONRESTOKEN_),
  ParKeyWord("RPAD",               TOK_RPAD,        NONRESTOKEN_),
  ParKeyWord("RTRIM",              TOK_RTRIM,       NONRESTOKEN_),
  ParKeyWord("RUN",                TOK_RUN,         NONRESTOKEN_),
  ParKeyWord("RUNNINGAVG",         TOK_RAVG,        NONRESTOKEN_),
  ParKeyWord("RUNNINGCOUNT",       TOK_RCOUNT,      NONRESTOKEN_),
  ParKeyWord("RUNNINGMAX",         TOK_RMAX,        NONRESTOKEN_),
  ParKeyWord("RUNNINGMIN",         TOK_RMIN,        NONRESTOKEN_),
  ParKeyWord("RUNNINGRANK",        TOK_RRANK,       NONRESTOKEN_),
  ParKeyWord("RUNNINGSTDDEV",      TOK_RSTDDEV,     NONRESTOKEN_),
  ParKeyWord("RUNNINGSUM",         TOK_RSUM,        NONRESTOKEN_),
  ParKeyWord("RUNNINGVARIANCE",    TOK_RVARIANCE,   NONRESTOKEN_),
  ParKeyWord("SAFE",               TOK_SAFE,        NONRESTOKEN_),
  ParKeyWord("SALT",               TOK_SALT,        NONRESTOKEN_),
  ParKeyWord("SAS_FORMAT",         TOK_SAS_FORMAT,  NONRESTOKEN_),
  ParKeyWord("SAS_LOCALE",         TOK_SAS_LOCALE,  NONRESTOKEN_),
  ParKeyWord("SAS_MODEL_INPUT_TABLE", TOK_SAS_MODEL_INPUT_TABLE,  NONRESTOKEN_),
  ParKeyWord("SAMPLE",             TOK_SAMPLE,      FIRST_|NONRESTOKEN_),
  ParKeyWord("SAVEPOINT",          IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("SCALAR",             TOK_SCALAR,      NONRESTOKEN_),
  ParKeyWord("SCALE",              TOK_SCALE,       NONRESTOKEN_),
  ParKeyWord("SCAN",               TOK_SCAN,       NONRESTOKEN_),
  ParKeyWord("SCHEMA",             TOK_SCHEMA,      ANS_|RESWORD_),
  ParKeyWord("SCHEMAS",            TOK_SCHEMAS,     NONRESTOKEN_),
  ParKeyWord("SCHEMA_NAME",        TOK_SCHEMA_NAME, NONRESTOKEN_),
  ParKeyWord("SCROLL",             IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("SCOPE",              TOK_SCOPE,       COMPAQ_|RESWORD_),
  ParKeyWord("SERIALIZED",             TOK_SERIALIZED,      NONRESTOKEN_),
  ParKeyWord("SEARCH",             IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("STRING_SEARCH",      TOK_STRING_SEARCH,        NONRESTOKEN_),
  ParKeyWord("SECOND",             TOK_SECOND,      ANS_|RESWORD_),
  ParKeyWord("SECONDS",            TOK_SECONDS,     NONRESTOKEN_),
  ParKeyWord("SECTION",            TOK_SECTION,     ANS_|RESWORD_),
  ParKeyWord("SECURITY",           TOK_SECURITY,    NONRESTOKEN_),  
  ParKeyWord("SEL",                TOK_SEL,         NONRESTOKEN_),
  ParKeyWord("SELECT",             TOK_SELECT,      ANS_|RESWORD_),
  ParKeyWord("SELECTIVITY",        TOK_SELECTIVITY, NONRESTOKEN_),
  ParKeyWord("SENSITIVE",          IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("SEPARATE",           TOK_SEPARATE,    NONRESTOKEN_),
  ParKeyWord("SEPARATOR",          TOK_SEPARATOR,    NONRESTOKEN_),
  ParKeyWord("SEQNUM",           TOK_SEQNUM,    NONRESTOKEN_),
  ParKeyWord("SEQUENCE",           TOK_SEQUENCE,    FIRST_|NONRESTOKEN_|SECOND_),
  ParKeyWord("SEQUENCES",           TOK_SEQUENCES,    NONRESTOKEN_),
  ParKeyWord("SERIALIZABLE",       TOK_SERIALIZABLE, FIRST_|SECOND_|NONRESTOKEN_),
  ParKeyWord("STRINGTOLOB",        TOK_STRINGTOLOB,   NONRESTOKEN_),
  ParKeyWord("STRINGTOEXTERNAL",        TOK_STRINGTOEXTERNAL,   NONRESTOKEN_),
  ParKeyWord("SERVER_NAME",        TOK_SERVER_NAME, NONRESTOKEN_),
  ParKeyWord("SESSION",            TOK_SESSION,     ANS_|RESWORD_),
  ParKeyWord("SESSIONS",           TOK_SESSIONS,    NONRESTOKEN_), 
  ParKeyWord("SESSION_USER",       TOK_SESSION_USER, ANS_|RESWORD_),
  ParKeyWord("SESSN_USR_INTN",     TOK_SESSN_USR_INTN, RESWORD_),
  ParKeyWord("SET",                TOK_SET,         ANS_|RESWORD_),
  ParKeyWord("SETS",               TOK_SETS,        COMPAQ_|RESWORD_),
  ParKeyWord("SG_TABLE",           TOK_SG_TABLE,    NONRESTOKEN_),
  ParKeyWord("SHA",                TOK_SHA,         NONRESTOKEN_),
  ParKeyWord("SHA1",               TOK_SHA1,        NONRESTOKEN_),
  ParKeyWord("SHA2",               TOK_SHA2,        NONRESTOKEN_),
  ParKeyWord("SHAPE",              TOK_SHAPE,       NONRESTOKEN_),
  ParKeyWord("SHARE",              TOK_SHARE,       NONRESTOKEN_),
  ParKeyWord("SHARED",             TOK_SHARED,      NONRESTOKEN_),
  ParKeyWord("SHOW",               TOK_SHOW,        NONRESTOKEN_),
  ParKeyWord("SHOWCONTROL",        TOK_SHOWCONTROL, NONRESTOKEN_),
  ParKeyWord("SHOWDDL",            TOK_SHOWDDL,     NONRESTOKEN_|FIRST_),
  ParKeyWord("SHOWPLAN",           TOK_SHOWPLAN,    NONRESTOKEN_),
  ParKeyWord("SHOWSET",            TOK_SHOWSET,     NONRESTOKEN_),
  ParKeyWord("SHOWSHAPE",          TOK_SHOWSHAPE,   NONRESTOKEN_),
  ParKeyWord("SHOWSTATS",          TOK_SHOWSTATS,   NONRESTOKEN_),
  ParKeyWord("SHOWTRANSACTION",    TOK_SHOWTRANSACTION, NONRESTOKEN_),
  ParKeyWord("SIGN",               TOK_SIGN,        NONRESTOKEN_),
  ParKeyWord("SIGNAL",             TOK_SIGNAL,      COMPAQ_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("SIGNED",             TOK_SIGNED,      NONRESTOKEN_),
  ParKeyWord("SIMILAR",            IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("SIMULATE",        TOK_SIMULATE,    NONRESTOKEN_),
  ParKeyWord("SIN",                TOK_SIN,         NONRESTOKEN_),
  ParKeyWord("SINCE",              TOK_SINCE,       NONRESTOKEN_),
  ParKeyWord("SINGLEDELTA",        TOK_SINGLEDELTA, FLAGSNONE_),
  ParKeyWord("SINH",               TOK_SINH,        NONRESTOKEN_),
  ParKeyWord("SIZE",               TOK_SIZE,        ANS_|RESWORD_),
  ParKeyWord("SKIP",               TOK_SKIP,        FIRST_|SECOND_|NONRESTOKEN_),
  ParKeyWord("SLACK",              TOK_SLACK,        NONRESTOKEN_),
  ParKeyWord("SLEEP",              TOK_SLEEP,        NONRESTOKEN_),
  ParKeyWord("SMALLINT",           TOK_SMALLINT,    ANS_|RESWORD_),
  ParKeyWord("SNAPSHOT",           TOK_SNAPSHOT,    NONRESTOKEN_),
  ParKeyWord("SOFTWARE",           TOK_SOFTWARE,    NONRESTOKEN_),
  ParKeyWord("SOME",               TOK_SOME,        ANS_|RESWORD_),
  ParKeyWord("SOUNDEX",            TOK_SOUNDEX,     NONRESTOKEN_),
  ParKeyWord("SORT",               TOK_SORT,        NONRESTOKEN_),
  ParKeyWord("SORT_KEY",           TOK_SORT_KEY,    NONRESTOKEN_),
  ParKeyWord("SOURCE",             TOK_SOURCE,      NONRESTOKEN_),
  ParKeyWord("SOURCE_FILE",        TOK_SOURCE_FILE, NONRESTOKEN_),
  ParKeyWord("SPACE",              TOK_SPACE,       NONRESTOKEN_),
  ParKeyWord("SPECIFIC",           TOK_SPECIFIC,    COMPAQ_|RESWORD_),
  ParKeyWord("SPECIFICTYPE",       TOK_SPECIFICTYPE, COMPAQ_|RESWORD_),
  ParKeyWord("SPLIT_PART",         TOK_SPLIT_PART, NONRESTOKEN_),
  ParKeyWord("SP_RESULT_SET",      TOK_SP_RESULT_SET, NONRESTOKEN_),
  ParKeyWord("SQL",                TOK_SQL,         ANS_|RESWORD_|SECOND_),
  ParKeyWord("SQLCODE",            TOK_SQLCODE,     ANS_|RESWORD_),
  ParKeyWord("SQLERROR",           TOK_SQLERROR,    ANS_|RESWORD_),
  ParKeyWord("SQLEXCEPTION",       IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("SQLROW",             TOK_SQLROW,      NONRESTOKEN_),
  ParKeyWord("SQLSTATE",           TOK_SQLSTATE,    ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("SQLWARNING",         IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("SQL_BIGINT",         TOK_LARGEINT,    NONRESTOKEN_),
  ParKeyWord("SQL_CHAR",           TOK_CHARACTER,   COMPAQ_|RESWORD_),
  ParKeyWord("SQL_DATE",           TOK_DATE,        COMPAQ_|RESWORD_),
  ParKeyWord("SQL_DECIMAL",        TOK_DECIMAL,     COMPAQ_|RESWORD_),
  ParKeyWord("SQL_DOUBLE",         TOK_SQL_DOUBLE,  COMPAQ_|RESWORD_),
  ParKeyWord("SQL_FLOAT",          TOK_FLOAT,       COMPAQ_|RESWORD_),
  ParKeyWord("SQL_INT",            TOK_INTEGER,     COMPAQ_|RESWORD_),
  ParKeyWord("SQL_INTEGER",        TOK_INTEGER,     COMPAQ_|RESWORD_),
  ParKeyWord("SQL_REAL",           TOK_REAL,        COMPAQ_|RESWORD_),
  ParKeyWord("SQL_SMALLINT",       TOK_SMALLINT,    COMPAQ_|RESWORD_),
  ParKeyWord("SQL_TIME",           TOK_TIME,        COMPAQ_|RESWORD_),
  ParKeyWord("SQL_TIMESTAMP",      TOK_TIMESTAMP,   COMPAQ_|RESWORD_),
  ParKeyWord("SQL_VARCHAR",        TOK_VARCHAR,     COMPAQ_|RESWORD_),
  ParKeyWord("SQL_WARNING",        TOK_SQL_WARNING, NONRESTOKEN_),
  ParKeyWord("SQRT",               TOK_SQRT,        NONRESTOKEN_),
  ParKeyWord("START",              TOK_START,       COMPAQ_|NONRESWORD_),
// used in nist618 test
  ParKeyWord("STATE",              TOK_STATE,       COMPAQ_|NONRESWORD_),
// used in QAT tests
  ParKeyWord("STATEMENT",          TOK_STATEMENT,   NONRESTOKEN_),
  ParKeyWord("STATIC",             TOK_STATIC,      NONRESTOKEN_),
  ParKeyWord("STATISTICS",         TOK_STATISTICS,  NONRESTOKEN_),
  ParKeyWord("STATS",              TOK_STATS,       NONRESTOKEN_),
  ParKeyWord("STATUS",             TOK_STATUS,      NONRESTOKEN_),
  ParKeyWord("STDDEV",             TOK_STDDEV,      NONRESTOKEN_),
  ParKeyWord("STOP",               TOK_STOP,        NONRESTOKEN_),
  ParKeyWord("STORAGE",            TOK_STORAGE,     NONRESTOKEN_),
  ParKeyWord("STORE",              TOK_STORE,       NONRESTOKEN_),
  ParKeyWord("STORED",             TOK_STORED,      NONRESTOKEN_),
  ParKeyWord("STREAM",             TOK_STREAM,      NONRESTOKEN_),
  ParKeyWord("STRUCTURE",          IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("STYLE",              TOK_STYLE,       NONRESTOKEN_),
  ParKeyWord("SUBCLASS_ORIGIN",    TOK_SUBCLASS_ORIGIN, NONRESTOKEN_),
  ParKeyWord("SUBSTR",             TOK_SUBSTRING,   NONRESTOKEN_),
  ParKeyWord("SUBSTRING",          TOK_SUBSTRING,   ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("SUBSYSTEM_ID",       TOK_SUBSYSTEM_ID, NONRESTOKEN_),
  ParKeyWord("SUFFIX",             TOK_SUFFIX,       NONRESTOKEN_),
  ParKeyWord("SUM",                TOK_SUM,         ANS_|RESWORD_),
  ParKeyWord("SUMMARY",            TOK_SUMMARY,     NONRESTOKEN_),
  ParKeyWord("SUSPEND",            TOK_SUSPEND,     NONRESTOKEN_),
  ParKeyWord("SYNONYM",            TOK_SYNONYM,     POTANS_|RESWORD_),
  ParKeyWord("SYNONYMS",           TOK_SYNONYMS,    NONRESTOKEN_),
  ParKeyWord("SYSDATE",            TOK_SYSDATE,     NONRESTOKEN_),
  ParKeyWord("SYS_GUID",           TOK_SYS_GUID,     NONRESTOKEN_),
  ParKeyWord("SYSTEM",             TOK_SYSTEM,      NONRESTOKEN_),
  ParKeyWord("SYSTIMESTAMP",            TOK_SYSTIMESTAMP,     NONRESTOKEN_),
  ParKeyWord("SYSTEM_USER",        IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("T",                  TOK_T,           NONRESTOKEN_),
  ParKeyWord("TAG",                TOK_TAG,         NONRESTOKEN_),
  ParKeyWord("TABLE",              TOK_TABLE,       ANS_|RESWORD_),
  ParKeyWord("TABLES",             TOK_TABLES,      FLAGSNONE_),
  ParKeyWord("TABLESPACE",             TOK_TABLESPACE,      NONRESTOKEN_),
  ParKeyWord("TABLE_MAPPING",      TOK_TABLE_MAPPING, NONRESTOKEN_),
  ParKeyWord("TABLE_NAME",         TOK_TABLE_NAME,  NONRESTOKEN_),
  ParKeyWord("TAN",                TOK_TAN,         NONRESTOKEN_),
  ParKeyWord("TANH",               TOK_TANH,        NONRESTOKEN_),
  ParKeyWord("TARGET",             TOK_TARGET,      NONRESTOKEN_),
  ParKeyWord("TDMISP",             TOK_INTERNALSP,  NONRESTOKEN_),
  ParKeyWord("TEMPORARY",          TOK_TEMPORARY,   ANS_|RESWORD_),
  ParKeyWord("TEMP_TABLE",         TOK_TEMP_TABLE,     NONRESTOKEN_),
  ParKeyWord("TERMINATE",          TOK_TERMINATE,   COMPAQ_|RESWORD_),
  ParKeyWord("TEST",               IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("TEXT",               TOK_TEXT,        NONRESTOKEN_),
  ParKeyWord("THAN",               TOK_THAN,        COMPAQ_|RESWORD_),
  ParKeyWord("THEN",               TOK_THEN,        ANS_|RESWORD_),
  ParKeyWord("THERE",              IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("THIS",               TOK_THIS,        NONRESTOKEN_),
  ParKeyWord("THROUGH",            TOK_THROUGH,     NONRESTOKEN_),
  ParKeyWord("TIME",               TOK_TIME,        FIRST_|ANS_|RESWORD_),
  ParKeyWord("TIMEOUT",            TOK_TIMEOUT,     NONRESTOKEN_),
  ParKeyWord("TIMESTAMP",          TOK_TIMESTAMP,   ANS_|RESWORD_),
  ParKeyWord("TIMESTAMPADD",       TOK_TIMESTAMPADD,NONRESTOKEN_),
  ParKeyWord("TIMESTAMPDIFF",      TOK_TIMESTAMPDIFF,NONRESTOKEN_),
  ParKeyWord("TIMEZONE_HOUR",      IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("TIMEZONE_MINUTE",    IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("TINYINT",            TOK_TINYINT,     NONRESTOKEN_),
  ParKeyWord("TITLE",              TOK_TITLE,       NONRESTOKEN_),
  ParKeyWord("TO",                 TOK_TO,          ANS_|RESWORD_),
  ParKeyWord("TO_CHAR",            TOK_TO_CHAR,     NONRESTOKEN_),
  ParKeyWord("TO_DATE",            TOK_TO_DATE,     NONRESTOKEN_),
  ParKeyWord("TO_NUMBER",          TOK_TO_NUMBER,   NONRESTOKEN_),
  ParKeyWord("TO_TIME",            TOK_TO_TIME,   NONRESTOKEN_),
  ParKeyWord("TO_TIMESTAMP",       TOK_TO_TIMESTAMP,   NONRESTOKEN_),
  ParKeyWord("TOKENSTR",           TOK_TOKENSTR,    NONRESTOKEN_),
  ParKeyWord("TRAFODION",          TOK_TRAFODION,    NONRESTOKEN_),
  ParKeyWord("TRAILING",           TOK_TRAILING,    ANS_|RESWORD_),
  ParKeyWord("TRANSACTION",        TOK_TRANSACTION, ANS_|RESWORD_),
  ParKeyWord("TRANSFORM",          TOK_TRANSFORM,   NONRESTOKEN_),
  ParKeyWord("TRANSLATE",          TOK_TRANSLATE,   ANS_|RESWORD_),
  ParKeyWord("TRANSLATION",        IDENTIFIER,      ANS_|RESWORD_),
  ParKeyWord("TRANSPOSE",          TOK_TRANSPOSE,   COMPAQ_|RESWORD_),
  ParKeyWord("TREAT",              TOK_TREAT,       COMPAQ_|RESWORD_),
  ParKeyWord("TRIGGER",            TOK_TRIGGER,     ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("TRIGGERS",           TOK_TRIGGERS,    NONRESTOKEN_),
  ParKeyWord("TRIGGER_CATALOG",    TOK_TRIGGER_CATALOG, NONRESTOKEN_),
  ParKeyWord("TRIGGER_NAME",       TOK_TRIGGER_NAME, NONRESTOKEN_),
  ParKeyWord("TRIGGER_SCHEMA",     TOK_TRIGGER_SCHEMA, NONRESTOKEN_),
  ParKeyWord("TRIM",               TOK_TRIM,        ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("TRUE",               TOK_TRUE,        ANS_|RESWORD_),
  ParKeyWord("TRUNC",              TOK_TRUNC,    NONRESTOKEN_),
  ParKeyWord("TRUNCATE",           TOK_TRUNCATE,    NONRESTOKEN_),
  ParKeyWord("TS",                 TOK_TS,          NONRESTOKEN_),
  ParKeyWord("TYPE",               TOK_TYPE,        NONRESTOKEN_),
  ParKeyWord("TYPECAST",               TOK_TYPECAST,        NONRESTOKEN_),
  ParKeyWord("TYPES",              TOK_TYPES,       NONRESTOKEN_),
  ParKeyWord("TYPE_ANSI",          TOK_TYPE_ANSI,   NONRESTOKEN_),
  ParKeyWord("TYPE_FS",            TOK_TYPE_FS,     NONRESTOKEN_),
  ParKeyWord("UCASE",              TOK_UCASE,       NONRESTOKEN_),
  ParKeyWord("UDF",                TOK_UDF,         NONRESTOKEN_),
  ParKeyWord("UID",		   TOK_UID,	    NONRESTOKEN_),
  ParKeyWord("UNAVAILABLE",        TOK_UNAVAILABLE, FLAGSNONE_),
  ParKeyWord("UNBOUNDED",          TOK_UNBOUNDED,   NONRESTOKEN_),
  ParKeyWord("UNCOMMITTED",        TOK_UNCOMMITTED, NONRESTOKEN_),
  ParKeyWord("UNDER",              IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("UNION",              TOK_UNION,       FIRST_|ANS_|RESWORD_),
  ParKeyWord("UNIQUE",             TOK_UNIQUE,      ANS_|RESWORD_),
  ParKeyWord("UNIQUE_ID",             TOK_UNIQUE_ID,      NONRESTOKEN_),
  ParKeyWord("UNIVERSAL",          TOK_UNIVERSAL,   NONRESTOKEN_),
  ParKeyWord("UNIX_TIMESTAMP",     TOK_UNIX_TIMESTAMP,   NONRESTOKEN_),
  ParKeyWord("UNKNOWN",            TOK_UNKNOWN,     ANS_|RESWORD_),
  ParKeyWord("UNLOAD",             TOK_UNLOAD,      NONRESTOKEN_),
  ParKeyWord("UNLOCK",             TOK_UNLOCK,      NONRESTOKEN_),
  ParKeyWord("UNNAMED",            TOK_UNNAMED,     NONRESTOKEN_),
  ParKeyWord("UNNEST",             TOK_UNNEST,      COMPAQ_|RESWORD_),
  ParKeyWord("UNREGISTER",         TOK_UNREGISTER,  NONRESTOKEN_),
  ParKeyWord("UNSIGNED",           TOK_UNSIGNED,    NONRESTOKEN_),
  ParKeyWord("UPDATE",             TOK_UPDATE,      FIRST_|ANS_|RESWORD_),
  ParKeyWord("UPD",                TOK_UPD,         NONRESTOKEN_),
  ParKeyWord("UPDATE_STATS",       TOK_UPDATE_STATS,	  NONRESTOKEN_),
  ParKeyWord("UPGRADE",                TOK_UPGRADE,         NONRESTOKEN_),
  ParKeyWord("UPPER",              TOK_UPPER,       ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("UPPERCASE",          TOK_UPPERCASE,   NONRESTOKEN_),
  ParKeyWord("UPSERT",              TOK_UPSERT,       NONRESTOKEN_),
  ParKeyWord("UPSHIFT",            TOK_UPSHIFT,     COMPAQ_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("USA",                TOK_USA,         NONRESTOKEN_),
  ParKeyWord("USAGE",              TOK_USAGE,       ANS_|RESWORD_),
  ParKeyWord("USE",                TOK_USE,         FLAGSNONE_),
  ParKeyWord("USER",               TOK_USER,        ANS_|RESWORD_),
  ParKeyWord("USERNAME_INT_TO_EXT",TOK_USERNAMEINTTOEXT,  NONRESTOKEN_),
  ParKeyWord("USERS",              TOK_USERS,       NONRESTOKEN_),
  ParKeyWord("USING",              TOK_USING,       ANS_|RESWORD_),
  ParKeyWord("UUID",                TOK_UUID,         NONRESTOKEN_),
  ParKeyWord("UUID_SHORT",          TOK_UUID_SHORT,	NONRESTOKEN_),
  ParKeyWord("VALIDATE",	   TOK_VALIDATE,    NONRESTOKEN_),
  ParKeyWord("VALUE",              TOK_VALUE,       NONRESTOKEN_),
  ParKeyWord("VALUES",             TOK_VALUES,      ANS_|RESWORD_),
  ParKeyWord("VARBINARY",          TOK_VARBINARY,   NONRESTOKEN_),
  ParKeyWord("VARCHAR",            TOK_VARCHAR,     ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("VARCHAR2",            TOK_VARCHAR,     ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("VARIABLE",           IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("VARIABLE_DATA",      TOK_VARIABLE_DATA, NONRESTOKEN_),
  ParKeyWord("VARIABLE_POINTER",   TOK_VARIABLE_POINTER, NONRESTOKEN_),
  ParKeyWord("VARIANCE",           TOK_VARIANCE,    NONRESTOKEN_),
  ParKeyWord("VARWCHAR",           TOK_VARWCHAR,    NONRESTOKEN_),
  ParKeyWord("VARYING",            TOK_VARYING,     ANS_|RESWORD_|NONRESTOKEN_),
  ParKeyWord("VERIFY",             TOK_VERIFY,      NONRESTOKEN_),
  ParKeyWord("VERSION",            TOK_VERSION,     NONRESTOKEN_),
  ParKeyWord("VERSIONS",            TOK_VERSIONS,     NONRESTOKEN_),
  ParKeyWord("VERSION_INFO",       TOK_VERSION_INFO, NONRESTOKEN_),
  ParKeyWord("VIEW",               TOK_VIEW,        ANS_|RESWORD_),
  ParKeyWord("VIEWS",              TOK_VIEWS,       NONRESTOKEN_),
  ParKeyWord("VIRTUAL",            IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("VISIBLE",            IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("VOLATILE",           TOK_VOLATILE,    NONRESTOKEN_),
  ParKeyWord("VPROC",              TOK_VPROC,       NONRESTOKEN_),
  ParKeyWord("VSBB",               TOK_VSBB,        NONRESTOKEN_),
  ParKeyWord("WAIT",               IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("WAITED",             TOK_WAITED,      NONRESTOKEN_),
  ParKeyWord("WAITEDIO",           TOK_WAITEDIO,      NONRESTOKEN_),
  ParKeyWord("WCHAR",              TOK_WCHAR,       NONRESTOKEN_),
  ParKeyWord("WEEK",               TOK_WEEK,        NONRESTOKEN_),
  ParKeyWord("WHEN",               TOK_WHEN,        ANS_|RESWORD_),
  ParKeyWord("WHENEVER",           TOK_WHENEVER,    ANS_|RESWORD_),
  ParKeyWord("WHERE",              TOK_WHERE,       ANS_|RESWORD_),
  ParKeyWord("WHILE",              IDENTIFIER,      POTANS_|RESWORD_),
  ParKeyWord("WITH",               TOK_WITH,        SECOND_|ANS_|RESWORD_),
  ParKeyWord("WITHOUT",            TOK_WITHOUT,     SECOND_|POTANS_|RESWORD_),
  ParKeyWord("WORK",               TOK_WORK,        ANS_|RESWORD_),
  ParKeyWord("WOM",                TOK_WOM,         NONRESTOKEN_),
  ParKeyWord("WRITE",              TOK_WRITE,       ANS_|RESWORD_),
  ParKeyWord("XMLAGG",               TOK_XMLAGG,        NONRESTOKEN_),
  ParKeyWord("XMLELEMENT",               TOK_XMLELEMENT,        NONRESTOKEN_),
  ParKeyWord("YEAR",               TOK_YEAR,        ANS_|RESWORD_),
  ParKeyWord("ZEROIFNULL",         TOK_ZEROIFNULL,  NONRESTOKEN_),
  ParKeyWord("ZONE",               IDENTIFIER,      ANS_|RESWORD_)
};

// The maximum length of all the keywords.  This is used to be able to
// allocate a buffer large enough to hold any keyword.  This value is
// checked (once) at runtime to make sure it is still valid.
//
#define MAX_KEYWORD_LENGTH 30

// The static keyword for an IDENTIFIER.  Used when a given keyword
// was not found in the keyword table.
//
ParKeyWord ParKeyWords::identWord_("IDENT", IDENTIFIER, FLAGSNONE_);

// The number of entries in the keyword table.
// set once by initKeyWordTable().
//
size_t ParKeyWords::numEntries_(0);

// The maximum length of all the keywords.
// set once by initKeyWordTable().
//
size_t ParKeyWords::maxKeyWordLength_(0);

// Indicates if the keyword table has been sorted.
// FALSE - not sorted
// TRUE - sorted
//
// Initialized to FALSE (not sorted) and set to TRUE (sorted)
// by initKeyWordTable()
//
NABoolean ParKeyWords::keyWordTableSorted_(FALSE);

// Copy Constructor for ParKeyWord
//
ParKeyWord::ParKeyWord(const ParKeyWord &other, NAMemory * h)
  : keyword_(other.keyword_),
    tokenCode_(other.tokenCode_),
    flags_(other.flags_)
{}

// Basic constructor for a ParKeyWord.
//
ParKeyWord::ParKeyWord(const char *kwd,
                       Int32 code,
                       UInt32 flags,
                       NAMemory * h)
  : keyword_(kwd),
    tokenCode_(code),
    flags_(flags)
{
}

// Constructor for ParKeyWords.
//
ParKeyWords::ParKeyWords(NAMemory * h)
{
  initKeyWordTable();
}

// Copy Constructor for ParKeyWords
// (no data to copy)
//
ParKeyWords::ParKeyWords(const ParKeyWords &other, NAMemory * h)
{
  initKeyWordTable();
}

// ParKeyWord::useAsIdentifierInNonSpecialMode() =====================
// Do we use this word only as a reserved word in special modes 
// (otherwise as an identifier)
// ===================================================================
//
NABoolean 
ParKeyWord::useAsIdentifierInNonSpecialMode() const 
{    
  NABoolean useAsIdentifier = FALSE;

  if( !( SqlParser_CurrentParser->modeSpecial1() 
         || 
         CmpCommon::getDefault(COMP_BOOL_200) == DF_ON ) )
  {
    switch(tokenCode_)
    {
    case TOK_QUALIFY:
      useAsIdentifier = TRUE;
      break;
    default: 
      /* default is already FALSE */
      break;
    };  
  }
  return useAsIdentifier;
}

// ParKeyWords::initKeyWordTable() ====================================
// Initialize the key word table.  This will load in any changes to
// the table and sort it if these things have not already been done.
// ====================================================================
//
void
ParKeyWords::initKeyWordTable()
{
  // make sure keyword table is sorted and all static data has been
  // initialized. Do this only once.
  //
  if (!keyWordTableSorted_) {
    keyWordTableSorted_ = TRUE;

    // The number of entries in the keyword table.
    // (needed by qsort and bsearch).
    //
    numEntries_ = sizeof(keyWords_)/sizeof(ParKeyWord);

    // sort the keyword table.
    //
    qsort(keyWords_, numEntries_, sizeof(ParKeyWord), keyCompare);

    // Determine the max length of the keywords.
    // And ensure that all the words are in uppercase.
    //

    for(UInt32 i = 0; i < numEntries_; i++) {

      const char *kword = keyWords_[i].getKeyWord();
      UInt32 len = str_len(kword);

      if (maxKeyWordLength_ < len) {
         maxKeyWordLength_ = len;
      }

      for (UInt32 l = 0; l < len; l++) {
        ComASSERT(isUpper8859_1(kword[l]) || !isAlpha8859_1(kword[l]));
      }

    }

    // Add one for the NULL char.
    //
    maxKeyWordLength_++;

    // Make sure that the equivalent #define is still valid.
    //
    ComASSERT(maxKeyWordLength_ <= MAX_KEYWORD_LENGTH);

  }
} // ParKeyWords::initKeyWordTable()

// ParKeyWords::keyCompare() ===========================================
// key comparison function for keywordTable binary search
// returns: negative if keyval < datum (table entry)
//          zero if keyval == datum
//          positive if keyval > datum
// =====================================================================
//
Int32 ParKeyWords::keyCompare(const void *keyval, const void *datum)
{
  // Cast the (void *) pointers to the (ParKeyWord *) which they must
  // be.
  //
  ParKeyWord *kval = (ParKeyWord *)keyval;
  ParKeyWord *entry = (ParKeyWord *)datum;

  // If either entry is NULL or has a NULL keyword, return 0 (equal).
  //
  ComASSERT(kval && kval->getKeyWord() && entry && entry->getKeyWord());

  // case-sensitive comparison
  // (all words are uppercase)
  //
  Int32 len1 = str_len(kval->getKeyWord());
  Int32 len2 = str_len(entry->getKeyWord());

  Int32 ok = 0;

  if ( len1 == len2 )
    return  str_cmp(kval->getKeyWord(), entry->getKeyWord(), len1);
  else
    ok = strcmp(kval->getKeyWord(), entry->getKeyWord());
 
  if ( ok > 0 ) return 1;
  if ( ok < 0 ) return -1;
  
  return 0;
}

// normalizeKeyWord() ================================================
// static helper routine used by lookupKeyWord.  Used to narrow a wide
// string to a narrow string and convert to uppercase .  Note that all
// keywords can be represented as narrow words.
//
// wWord (IN) - a pointer to the WIDE word to be narrowed.
//
// word (IN) - a pointer to an allocated buffer used to hold the
//             narrow word.
//
// size (IN) - the size of the buffer (word).
//
// Returns boolean indicating if the word was successfully normalized.
// It will be unsuccessful if the word contains characters that can
// not be represented as a narrow character or if the size of the
// buffer is not large enough to hold the normalized word.
// ===================================================================
//
static
NABoolean normalizeKeyWord(NAWchar *wWord, char *word, UInt32 size)
{

  UInt32 i = 0;
  while (wWord[i]) {

    // If the Word is bigger than the buffer return FALSE.
    //
    if (i >= size - 1) {
      return FALSE;
    }

    // Convert the wide character to a regular character.
    //
    word[i] = (char)wWord[i];

    // Convert it back to the wide char.  If it is not the same,
    // then data was lost in the conversion.
    //
    if (((NAWchar)word[i] ) != wWord[i]) {
      return FALSE;
    }

    // Upper case all words since all the words in the keyword table
    // are also uppercase.
    //
    word[i] = TOUPPER(word[i]);

    i++;
  }
  word[i] = '\0';

  return TRUE;
}

// ParKeyWords::lookupKeyWord() ======================================
// Look up the narrowed version of the given word in the keyword
// table.  If found return a const pointer to the ParKeyWord
// object. If the word is too large, or cannot be narrowed, or is not
// found in the keyword table, return a const pointer to the static
// identWord_.
// ===================================================================
//
const
ParKeyWord *ParKeyWords::lookupKeyWord(NAWchar *id)
{

  // Buffer to hold the narrowed version of the given word.
  //
  char word[MAX_KEYWORD_LENGTH];

  // Narrow the given word.  If this is successful, search for the
  // word in the keyword table
  //
  if(normalizeKeyWord(id, word, maxKeyWordLength_)) {

    // search for word in the keyword table
    //
    ParKeyWord key(word, 0, 0);
    const ParKeyWord *entry = searchKeyWordTbl(&key);

    // If the word was found, return a const pointer to the ParKeyWord
    // entry.
    //
    if (entry &&
        (!entry->isConditionallyReserved() ||
         !entry->useAsIdentifierInNonSpecialMode())) {      
      return entry;
    }
  }

  // If 'id' could not be narrowed or it could not be found in the
  // keyword table, then it must be an identifier.  Return a pointer
  // to the static identifier entry.
  //
  return &identWord_;
}