/*******************************************************************************
 * 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.
 *******************************************************************************/
package org.apache.ofbiz.entity.model;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.GenericEntityException;

/**
 * Generic Entity - Entity Definition Checker
 *
 */
public class ModelEntityChecker {

    public static final String module = ModelEntityChecker.class.getName();

    public static void checkEntities(Delegator delegator, List<String> warningList) throws GenericEntityException {
        ModelReader reader = delegator.getModelReader();

        Set<String> reservedWords = new HashSet<String>();
        if (Debug.infoOn()) {
            Debug.logInfo("[initReservedWords] array length = " + rwArray.length, module);
        }
        for (int i = 0; i < rwArray.length; i++) {
            reservedWords.add(rwArray[i]);
        }

        Map<String, Set<String>> packages = new HashMap<String, Set<String>>();
        Set<String> packageNames = new TreeSet<String>();
        Set<String> tableNames = new HashSet<String>();

        //put the entityNames TreeSets in a HashMap by packageName
        Collection<String> ec = reader.getEntityNames();
        Set<String> entityNames = new HashSet<String>(ec);
        for (String eName: ec) {
            ModelEntity ent = reader.getModelEntity(eName);

            //make sure the table name is in the list of all table names, if
            // not null
            if (UtilValidate.isNotEmpty(ent.getPlainTableName()))
                    tableNames.add(ent.getPlainTableName());

            Set<String> entities = packages.get(ent.getPackageName());
            if (entities == null) {
                entities = new TreeSet<String>();
                packages.put(ent.getPackageName(), entities);
                packageNames.add(ent.getPackageName());
            }
            entities.add(eName);
        }

        Set<String> fkNames = new HashSet<String>();
        Set<String> indexNames = new HashSet<String>();

        for (String pName: packageNames) {
            Set<String> entities = packages.get(pName);
            for (String entityName: entities) {
                String helperName = delegator.getEntityHelperName(entityName);
                String groupName = delegator.getEntityGroupName(entityName);
                ModelEntity entity = reader.getModelEntity(entityName);
                if (helperName == null) {
                    //only show group name warning if helper name not found
                    if (UtilValidate.isEmpty(groupName)) {
                            warningList.add("[GroupNotFound] No Group Name found for entity " + entity.getEntityName() + ".");
                    } else {
                        warningList.add("[HelperNotFound] No Helper (DataSource) definition found for entity [" + entity.getEntityName() + "] because there is no helper (datasource) configured for the entity group it is in: [" + groupName + "]");
                    }
                }
                if (entity.getPlainTableName() != null && entity.getPlainTableName().length() > 30) {
                        warningList.add("[TableNameGT30] Table name [" + entity.getPlainTableName() + "] of entity " + entity.getEntityName() + " is longer than 30 characters.");
                }
                if (entity.getPlainTableName() != null && reservedWords.contains(entity.getPlainTableName().toUpperCase())) {
                        warningList.add("[TableNameRW] Table name [" + entity.getPlainTableName() + "] of entity " + entity.getEntityName() + " is a reserved word.");
                }
                
                // don't check columns/relations/keys when never-check is set to "true"
                if (entity.getNeverCheck()) {
                    continue;
                }
                
                Set<String> ufields = new HashSet<String>();
                Iterator<ModelField> fieldIter = entity.getFieldsIterator();
                while (fieldIter.hasNext()) {
                    ModelField field = fieldIter.next();
                    ModelFieldType type = delegator.getEntityFieldType(entity,field.getType());

                    if (ufields.contains(field.getName())) {
                        warningList.add("[FieldNotUnique] Field [" + field.getName() + " of entity " + entity.getEntityName() + " is not unique for that entity.");
                    } else {
                        ufields.add(field.getName());
                    }
                    if (field.getColName().length() > 30 && !(entity instanceof ModelViewEntity)) {
                        warningList.add("[FieldNameGT30] Column name [" + field.getColName() + "] of entity " + entity.getEntityName() + " is longer than 30 characters.");
                    }
                    if (field.getColName().length() == 0) {
                        warningList.add("[FieldNameEQ0] Column name for field name \"" + field.getName() + "\" of entity " + entity.getEntityName() + " is empty (zero length).");
                    }
                    if (reservedWords.contains(field.getColName().toUpperCase()))
                            warningList.add("[FieldNameRW] Column name " + field.getColName() + " of entity " + entity.getEntityName() + " is a reserved word.");
                    if (type == null) {
                        StringBuilder warningMsg = new StringBuilder();
                        warningMsg.append("[FieldTypeNotFound] Field type " + field.getType() + " of entity " + entity.getEntityName() + " not found in field type definitions");
                        if (helperName == null) {
                            warningMsg.append(" (no helper definition found)");
                        }
                        warningMsg.append(".");
                        warningList.add(warningMsg.toString());
                    }
                }
                if (entity.getRelationsSize() > 0) {
                    Iterator<ModelIndex> indexIter = entity.getIndexesIterator();
                    while (indexIter.hasNext()) {
                        ModelIndex index = indexIter.next();

                        if (indexNames.contains(index.getName())) {
                            warningList.add("[IndexDuplicateName] Index on entity "
                                            + entity.getEntityName() + " has a duplicate index-name \""
                                            + index.getName() + "\".");
                        } else {
                            indexNames.add(index.getName());
                        }

                        if (tableNames.contains(index.getName())) {
                            warningList.add("[IndexTableDupName] Index on entity "
                                            + entity.getEntityName() + " has an index-name \""
                                            + index.getName() + "\" that is also being used as a table name.");
                        }

                        if (fkNames.contains(index.getName())) {
                            warningList.add("[IndexFKDupName] Index on entity "
                                            + entity.getEntityName()
                                            + " has an index-name \""
                                            + index.getName()
                                            + "\" that is also being used as a Foreign Key name.");
                        }

                        // make sure all names are <= 18 characters
                        if (index.getName().length() > 18) {
                            warningList.add("[IndexNameGT18] The index name " + index.getName() + " (length:" + index.getName().length()
                                            + ") was greater than 18 characters in length for entity " + entity.getEntityName() + ".");
                        }
                    }

                    Set<String> relations = new HashSet<String>();
                    for (int r = 0; r < entity.getRelationsSize(); r++) {
                        ModelRelation relation = entity.getRelation(r);

                        if (!entityNames.contains(relation.getRelEntityName())) {
                            warningList.add("[RelatedEntityNotFound] Related entity " + relation.getRelEntityName()
                                            + " of entity " + entity.getEntityName() + " not found.");
                        }
                        if (relations.contains(relation.getTitle() + relation.getRelEntityName())) {
                            warningList.add("[RelationNameNotUnique] Relation " + relation.getTitle() + relation.getRelEntityName()
                                            + " of entity "+ entity.getEntityName() + " is not unique for that entity.");
                        } else {
                            relations.add(relation.getTitle() + relation.getRelEntityName());
                        }

                        if (relation.getFkName().length() > 0) {
                            if (fkNames.contains(relation.getFkName())) {
                                warningList.add("[RelationFkDuplicate] Relation to "+ relation.getRelEntityName()
                                                + " from entity " + entity.getEntityName() + " has a duplicate fk-name \""
                                                + relation.getFkName() + "\".");
                            } else {
                                fkNames.add(relation.getFkName());
                            }
                            if (tableNames.contains(relation.getFkName())) {
                                warningList.add("[RelationFkTableDup] Relation to " + relation.getRelEntityName() + " from entity "
                                                + entity.getEntityName() + " has an fk-name \""
                                                + relation.getFkName() + "\" that is also being used as a table name.");
                            }
                            if (indexNames.contains(relation.getFkName())) {
                                warningList.add("[RelationFkTableDup] Relation to " + relation.getRelEntityName() + " from entity "
                                                + entity.getEntityName() + " has an fk-name \""
                                                + relation.getFkName() + "\" that is also being used as an index name.");
                            }
                        }

                        // make sure all FK names are <= 18 characters
                        if (relation.getFkName().length() > 18) {
                            warningList.add("[RelFKNameGT18] The foreign key named " + relation.getFkName() 
                                            + " (length:" + relation.getFkName().length()
                                            + ") was greater than 18 characters in length for relation " + relation.getTitle() + relation.getRelEntityName()
                                            + " of entity " + entity.getEntityName() + ".");
                        }

                        ModelEntity relatedEntity = null;
                        try {
                            relatedEntity = reader.getModelEntity(relation.getRelEntityName());
                        } catch (GenericEntityException e) {
                            Debug.logInfo("Entity referred to in relation is not defined: " + relation.getRelEntityName(), module);
                        }
                        if (relatedEntity != null) {
                            //if relation is of type one, make sure keyMaps
                            // match the PK of the relatedEntity
                            if ("one".equals(relation.getType()) || "one-nofk".equals(relation.getType())) {
                                if (relatedEntity.getPksSize() != relation.getKeyMaps().size())
                                        warningList.add("[RelatedOneKeyMapsWrongSize] The number of primary keys (" + relatedEntity.getPksSize()
                                                        + ") of related entity " + relation.getRelEntityName()
                                                        + " does not match the number of keymaps (" + relation.getKeyMaps().size()
                                                        + ") for relation of type one \"" + relation.getTitle() + relation.getRelEntityName()
                                                        + "\" of entity " + entity.getEntityName() + ".");
                                Iterator<ModelField> pksIter = relatedEntity.getPksIterator();
                                while (pksIter.hasNext()) {
                                    ModelField pk = pksIter.next();
                                    if (relation.findKeyMapByRelated(pk.getName()) == null) {
                                        warningList.add("[RelationOneRelatedPrimaryKeyMissing] The primary key \"" + pk.getName()
                                                        + "\" of related entity " + relation.getRelEntityName()
                                                        + " is missing in the keymaps for relation of type one " + relation.getTitle() + relation.getRelEntityName()
                                                        + " of entity " + entity.getEntityName() + ".");
                                    }
                                }
                            }
                        }

                        //make sure all keyMap 'fieldName's match fields of
                        // this entity
                        //make sure all keyMap 'relFieldName's match fields of
                        // the relatedEntity
                        for (ModelKeyMap keyMap : relation.getKeyMaps()) {

                            ModelField field = entity.getField(keyMap.getFieldName());
                            ModelField rfield = null;
                            if (relatedEntity != null) {
                                rfield = relatedEntity.getField(keyMap.getRelFieldName());
                            }
                            if (rfield == null) {
                                warningList.add("[RelationRelatedFieldNotFound] The field \"" + keyMap.getRelFieldName()
                                                + "\" of related entity " + relation.getRelEntityName()
                                                + " was specified in the keymaps but is not found for relation " + relation.getTitle() + relation.getRelEntityName()
                                                + " of entity " + entity.getEntityName() + ".");
                            }
                            if (field == null) {
                                warningList.add("[RelationFieldNotFound] The field " + keyMap.getFieldName()
                                                + " was specified in the keymaps but is not found for relation " + relation.getTitle() + relation.getRelEntityName()
                                                + " of entity " + entity.getEntityName() + ".");
                            }
                            if (field != null && rfield != null) {
                                //this was the old check, now more constrained
                                // to keep things cleaner:
                                // if (!field.getType().equals(rfield.getType())
                                // &&
                                // !field.getType().startsWith(rfield.getType())
                                // &&
                                // !rfield.getType().startsWith(field.getType()))
                                // {
                                if (!field.getType().equals(rfield.getType()) && !field.getType().equals(rfield.getType() + "-ne") && !rfield.getType().equals(field.getType() + "-ne")) {
                                    warningList.add("[RelationFieldTypesDifferent] The field type ("+ field.getType()
                                                    + ") of " + field.getName() + " of entity " + entity.getEntityName()
                                                    + " is not the same as field type (" + rfield.getType() + ") of "
                                                    + rfield.getName() + " of entity " + relation.getRelEntityName() + " for relation "
                                                    + relation.getTitle() + relation.getRelEntityName() + ".");
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    public static final String[] rwArray = { "ABORT", "ABS", "ABSOLUTE",
            "ACCEPT", "ACCES", "ACCESS", "ACS", "ACTION", "ACTIVATE", "ADD", "ADDFORM",
            "ADMIN", "AFTER", "AGGREGATE", "ALIAS", "ALL", "ALLOCATE", "ALTER",
            "ANALYZE", "AND", "ANDFILENAME", "ANY", "ANYFINISH", "APPEND",
            "ARCHIVE", "ARE", "ARRAY", "AS", "ASC", "ASCENDING", "ASCII",
            "ASSERT", "ASSERTION", "ASSIGN", "AT", "ATTRIBUTE", "ATTRIBUTES",
            "AUDIT", "AUTHID", "AUTHORIZATION", "AUTONEXT", "AUTO_INCREMENT",
            "AVERAGE", "AVG", "AVGU", "AVG_ROW_LENGTH",

            "BACKOUT", "BACKUP", "BEFORE", "BEGIN", "BEGINLOAD", "BEGINMODIFY",
            "BEGINNING", "BEGWORK", "BETWEEN", "BETWEENBY", "BINARY",
            "BINARY_INTEGER", "BIT", "BIT_LENGTH", "BLOB", "BODY", "BOOLEAN",
            "BORDER", "BOTH", "BOTTOM", "BREADTH", "BREAK", "BREAKDISPLAY",
            "BROWSE", "BUFERED", "BUFFER", "BUFFERED", "BULK", "BY", "BYTE",

            "CALL", "CANCEL", "CASCADE", "CASCADED", "CASE", "CAST", "CATALOG",
            "CHANGE", "CHAR", "CHAR_LENGTH", "CHAR_BASE", "CHARACTER",
            "CHARACTER_LENGTH", "CHAR_CONVERT", "CHECK", "CHECKPOINT",
            "CHECKSUM", "CHR2FL", "CHR2FLO", "CHR2FLOA", "CHR2FLOAT",
            "CHR2INT", "CLASS", "CLEAR", "CLEARROW", "CLIPPED", "CLOB",
            "CLOSE", "CLUSTER", "CLUSTERED", "CLUSTERING", "COALESCE", "COBOL",
            "COLD", "COLLATE", "COLLATION", "COLLECT", "COLUMN", "COLUMNS",
            "COMMAND", "COMMENT", "COMMIT", "COMMITTED", "COMPLETION",
            "COMPRESS", "COMPUTE", "CONCAT", "COND", "CONDITION", "CONFIG",
            "CONFIRM", "CONNECT", "CONNECTION", "CONSTANT", "CONSTRAINT",
            "CONSTRAINTS", "CONSTRUCT", "CONSTRUCTOR", "CONTAIN", "CONTAINS",
            "CONTAINSTABLE", "CONTINUE", "CONTROLROW", "CONVERT", "COPY",
            "CORRESPONDING", "COUNT", "COUNTU", "COUNTUCREATE", "CRASH",
            "CREATE", "CROSS", "CUBE", "CURRENT", "CURRENT_DATE",
            "CURRENT_PATH", "CURRENT_ROLE", "CURRENT_SESSION", "CURRENT_TIME",
            "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "CURVAL", "CYCLE",

            "DATA", "DATALINK", "DATABASE", "DATABASES", "DATAPAGES",
            "DATA_PGS", "DATE", "DATETIME", "DAY", "DAY_HOUR", "DAY_MINUTE",
            "DAY_SECOND", "DAYNUM", "DAYOFMONTH", "DAYOFWEEK", "DAYOFYEAR",
            "DBA", "DBCC", "DBE", "DBEFILE", "DBEFILEO", "DBEFILESET",
            "DBSPACE", "DBYTE", "DEALLOCATE", "DEC", "DECENDING", "DECIMAL",
            "DECLARE", "DEFAULT", "DEFAULTS", "DEFER", "DEFERRABLE", "DEFINE",
            "DEFINITION", "DELAY_KEY_WRITE", "DELAYED", "DELETE", "DELETEROW",
            "DENY", "DEPTH", "DEREF", "DESC", "DESCENDING", "DESCENDNG",
            "DESCRIBE", "DESCRIPTOR", "DESTPOS", "DESTROY", "DEVICE",
            "DEVSPACE", "DIAGNOSTICS", "DICTIONARY", "DIRECT", "DIRTY",
            "DISCONNECT", "DISK", "DISPLACE", "DISPLAY", "DISTINCT",
            "DISTINCTROW", "DISTRIBUTED", "DISTRIBUTION", "DIV", "DO", "DOES",
            "DOMAIN", "DOUBLE", "DOWN", "DROP", "DUAL", "DUMMY", "DUMP",
            "DUPLICATES",

            "EACH", "EBCDIC", "EDITADD", "EDITUPDATE", "ED_STRING", "ELSE",
            "ELSEIF", "ELSIF", "ENCLOSED", "END", "ENDDATA", "ENDDISPLAY",
            "ENDFORMS", "ENDIF", "ENDING", "ENDLOAD", "ENDLOOP", "ENDMODIFY",
            "ENDPOS", "ENDRETRIEVE", "ENDSELECT", "ENDWHILE", "END_ERROR",
            "END_EXEC", "END_FETCH", "END_FOR", "END_GET", "END_MODIFY",
            "END_PLACE", "END_SEGMENT_S", "END_SEGMENT_STRING", "END_STORE",
            "END_STREAM", "ENUM", "EQ", "EQUALS", "ERASE", "ERROR", "ERRLVL",
            "ERROREXIT", "ESCAPE", "ESCAPED", "EVALUATE", "EVALUATING",
            "EVERY", "EXCEPT", "EXCEPTION", "EXCLUSIVE", "EXEC", "EXECUTE",
            "EXISTS", "EXIT", "EXPAND", "EXPANDING", "EXPLAIN", "EXPLICIT",
            "EXTEND", "EXTENDS", "EXTENT", "EXTERNAL", "EXTRACT",

            "FALSE", "FETCH", "FIELD", "FIELDS", "FILE", "FILENAME",
            "FILLFACTOR", "FINALISE", "FINALIZE", "FINDSTR", "FINISH", "FIRST",
            "FIRSTPOS", "FIXED", "FL", "FLOAT", "FLOAT4", "FLOAT8", "FLUSH",
            "FOR", "FORALL", "FOREACH", "FOREIGN", "FORMAT", "FORMDATA",
            "FORMINIT", "FORMS", "FORTRAN", "FOUND", "FRANT", "FRAPHIC",
            "FREE", "FREETEXT", "FREETEXTTABLE", "FROM", "FRS", "FULL",
            "FUNCTION",

            "GE", "GENERAL", "GET", "GETFORM", "GETOPER", "GETROW", "GLOBAL",
            "GLOBALS", "GO", "GOTO", "GRANT", "GRANTS", "GRAPHIC", "GROUP",
            "GROUPING", "GT",

            "HANDLER", "HASH", "HAVING", "HEAP", "HEADER", "HELP", "HELPFILE",
            "HELP_FRS", "HIGH_PRIORITY", "HOLD", "HOLDLOCK", "HOSTS", "HOUR",
            "HOUR_MINUTE", "HOUR_SECOND",

            "IDENTIFIED", "IDENTIFIELD", "IDENTITY", "IDENTITY_INSERT", "IF",
            "IFDEF", "IGNORE", "IMAGE", "IMMEDIATE", "IMMIDIATE", "IMPLICIT",
            "IN", "INCLUDE", "INCREMENT", "INDEX", "INDEXED", "INDEXNAME",
            "INDEXPAGES", "INDICATOR", "INFIELD", "INFILE", "INFO", "INGRES",
            "INIT", "INITIAL", "INITIALISE", "INITIALIZE", "INITIALLY",
            "INITTABLE", "INNER", "INOUT", "INPUT", "INQUIRE_EQUEL",
            "INQUIRE_FRS", "INQUIRE_INGRES", "INQUIR_FRS", "INSERT",
            "INSERT_ID", "INSERTROW", "INSTRUCTIONS", "INT", "INT1", "INT2CHR",
            "INT2", "INT3", "INT4", "INT8", "INTEGER", "INTEGRITY",
            "INTERESECT", "INTERFACE", "INTERRUPT", "INTERSECT", "INTERVAL",
            "INTO", "INTSCHR", "INVOKE", "IS", "ISAM", "ISOLATION", "ITERATE",

            "JAVA", "JOIN", "JOURNALING",

            "KEY", "KEYS", "KILL",

            "LABEL", "LANGUAGE", "LARGE", "LAST", "LAST_INSERT_ID", "LASTPOS",
            "LATERAL", "LE", "LEADING", "LEAVE", "LEFT", "LENGTH", "LENSTR",
            "LESS", "LET", "LEVEL", "LIKE", "LIKEPROCEDURETP", "LIMIT",
            "LIMITED", "LINE", "LINENO", "LINES", "LINK", "LIST", "LISTEN",
            "LOAD", "LOADTABLE", "LOADTABLERESUME", "LOCAL", "LOCALTIME",
            "LOCALTIMESTAMP", "LOCATION", "LOCATOR", "LOCK", "LOCKING", "LOG",
            "LOGS", "LONG", "LONGBLOB", "LONGTEXT", "LOOP", "LOW_PRIORITY",
            "LOWER", "LPAD", "LT",

            "MAIN", "MANUITEM", "MARGIN", "MATCH", "MATCHES", "MATCHING",
            "MAX", "MAX_ROWS", "MAXEXTENTS", "MAXPUBLICUNION", "MAXRECLEN",
            "MDY", "MEDIUMBLOB", "MEDIUMINT", "MEDIUMTEXT", "MEETS", "MENU",
            "MENUITEM", "MENUITEMSCREEN", "MESSAGE", "MESSAGERELOCATE",
            "MESSAGESCROLL", "MFETCH", "MIDDLEINT", "MIN", "MIN_ROWS",
            "MINRECLEN", "MINRETURNUNTIL", "MINUS", "MINUTE", "MINUTE_SECOND",
            "MIRROREXIT", "MISLABEL", "MISSING", "MIXED", "MOD", "MODE",
            "MODIFIES", "MODIFY", "MODIFYREVOKEUPDATE", "MODULE", "MONEY",
            "MONITOR", "MONTH", "MONTHNAME", "MOVE", "MULTI", "MYISAM",

            "NAME", "NAMES", "NATIONAL", "NATURAL", "NATURALN", "NCHAR",
            "NCLOB", "NE", "NEED", "NEW", "NEWLOG", "NEXT", "NEXTSCROLLDOWN",
            "NEXTVAL", "NO", "NOAUDIT", "NOCHECK", "NOCOMPRESS", "NOCOPY",
            "NOCR", "NOJOURNALING", "NOLIST", "NOLOG", "NONCLUSTERED", "NONE",
            "NORMAL", "NORMALIZE", "NOSYSSORT", "NOT", "NOTFFOUND", "NOTFOUND",
            "NOTIFY", "NOTRANS", "NOTRIM", "NOTRIMSCROLLUP", "NOTROLLBACKUSER",
            "NOWAIT", "NULL", "NULLIF", "NULLIFY", "NULLSAVEUSING", "NULLVAL",
            "NUMBER", "NUMBER_BASE", "NUMERIC", "NXFIELD",

            "OBJECT", "OCIROWID", "OCTET_LENGTH", "OF", "OFF", "OFFLINE",
            "OFFSET", "OFFSETS", "OFSAVEPOINTVALUES", "OLD", "ON", "ONCE",
            "ONLINE", "ONLY", "ONSELECTWHERE", "ONTO", "OPAQUE", "OPEN",
            "OPENDATASOURCE", "OPENQUERY", "OPENROWSET", "OPENXML",
            "OPENSETWHILE", "OPENSLEEP", "OPERATION", "OPERATOR", "OPTIMIZE",
            "OPTION", "OPTIONALLY", "OPTIONS", "OR", "ORDER", "ORDERSQLWORK",
            "ORDINALITY", "ORGANIZATION", "ORSOMEWITH", "ORSORT", "OTHERS",
            "OTHERWISE", "OUT", "OUTER", "OUTFILE", "OUTPUT", "OUTPUT_PAGE",
            "OUTSTOP", "OVER", "OVERLAPS", "OWNER", "OWNERSHIP",

            "PACK_KEYS", "PACKAGE", "PAD", "PAGE", "PAGENO", "PAGES", "PARAM",
            "PARAMETER", "PARAMETERS", "PARTIAL", "PARTITION", "PASCAL",
            "PASSWORD", "PATH", "PATHNAME", "PATTERN", "PAUSE", "PCTFREE",
            "PERCENT", "PERIOD", "PERM", "PERMANENT", "PERMIT", "PERMITSUM",
            "PIPE", "PLACE", "PLAN", "PLI", "PLS_INTEGER", "POS", "POSITION",
            "POSITIVE", "POSITIVEN", "POSTFIX", "POWER", "PRAGMA", "PRECEDES",
            "PRECISION", "PREFIX", "PREORDER", "PREPARE", "PREPARETABLE",
            "PRESERVE", "PREV", "PREVIOUS", "PREVISION", "PRIMARY", "PRINT",
            "PRINTER", "PRINTSCREEN", "PRINTSCREENSCROLL", "PRINTSUBMENU",
            "PRINTSUMU", "PRIOR", "PRIV", "PRIVATE", "PRIVILAGES",
            "PRIVILAGESTHEN", "PRIVILEGES", "PROC", "PROCEDURE", "PROCESS",
            "PROCESSEXIT", "PROCESSLIST", "PROGRAM", "PROGUSAGE", "PROMPT",
            "PROMPTSCROLLDOWN", "PROMPTTABLEDATA", "PROTECT", "PSECT",
            "PUBLIC", "PUBLICREAD", "PUT", "PUTFORM", "PUTFORMSCROLLUP",
            "PUTFORMUNLOADTABLE", "PUTOPER", "PUTOPERSLEEP", "PUTROW",
            "PUTROWSUBMENU", "PUTROWUP",

            "QUERY", "QUICK", "QUIT",

            "RAISERROR", "RANGE", "RANGETO", "RAW", "RDB$DB_KEY", "RDB$LENGTH",
            "RDB$MISSING", "RDB$VALUE", "RDB4DB_KEY", "RDB4LENGTH",
            "RDB4MISSING", "RDB4VALUE", "READ", "READS", "READONLY",
            "READPASS", "READTEXT", "READWRITE", "READY", "READ_ONLY",
            "READ_WRITE", "REAL", "RECONFIGURE", "RECONNECT", "RECORD",
            "RECOVER", "RECURSIVE", "REDISPLAY", "REDISPLAYTABLEDATA",
            "REDISPLAYVALIDATE", "REDO", "REDUCED", "REF", "REFERENCES",
            "REFERENCING", "REGEXP", "REGISTER", "REGISTERUNLOADDATA",
            "REGISTERVALIDROW", "REJECT", "RELATIVE", "RELEASE", "RELOAD",
            "RELOCATE", "RELOCATEUNIQUE", "REMOVE", "REMOVEUPRELOCATEV",
            "REMOVEVALIDATE", "REMOVEWHENEVER", "RENAME", "REPEAT",
            "REPEATABLE", "REPEATED", "REPEATVALIDROW", "REPLACE",
            "REPLACEUNTIL", "REPLICATION", "REPLSTR", "REPORT",
            "REQUEST_HANDLE", "RESERVED_PGS", "RESERVING", "RESET", "RESIGNAL",
            "RESOURCE", "REST", "RESTART", "RESTORE", "RESTRICT", "RESULT",
            "RESUME", "RETRIEVE", "RETRIEVEUPDATE", "RETURN", "RETURNS",
            "RETURNING", "REVERSE", "REVOKE", "RIGHT", "RLIKE", "ROLE",
            "ROLLBACK", "ROLLFORWARD", "ROLLBACK", "ROLLUP", "ROUND",
            "ROUTINE", "ROW", "ROWCNT", "ROWCOUNT", "ROWGUID_COL", "ROWID",
            "ROWLABEL", "ROWNUM", "ROWS", "ROWTYPE", "RPAD", "RULE", "RUN",
            "RUNTIME",

            "SAMPLSTDEV", "SAVE", "SAVEPOINT", "SAVEPOINTWHERE", "SAVEVIEW",
            "SCHEMA", "SCOPE", "SCREEN", "SCROLL", "SCROLLDOWN", "SCROLLUP",
            "SEARCH", "SECOND", "SECTION", "SEGMENT", "SEL", "SELE", "SELEC",
            "SELECT", "SELUPD", "SEPERATE", "SEQUENCE", "SERIAL", "SESSION",
            "SESSION_USER", "SET", "SETOF", "SETS", "SETWITH", "SET_EQUEL",
            "SET_FRS", "SET_INGRES", "SETUSER", "SHARE", "SHARED", "SHORT",
            "SHOW", "SHUTDOWN", "SIGNAL", "SIZE", "SKIP", "SLEEP",
            "SMALLFLOAT", "SMALLINT", "SOME", "SONAME", "SORT", "SORTERD",
            "SOUNDS", "SOURCEPOS", "SPACE", "SPACES", "SPECIFIC",
            "SPECIFICTYPE", "SQL", "SQL_BIG_RESULT", "SQL_BIG_SELECTS",
            "SQL_BIG_TABLES", "SQL_LOG_OFF", "SQL_LOG_UPDATE",
            "SQL_LOW_PRIORITY_UPDATES", "SQL_SELECT_LIMIT", "SQL_SMALL_RESULT",
            "SQL_WARNINGS", "SQLCODE", "SQLDA", "SQLERRM", "SQLERROR",
            "SQLEXCEPTION", "SQLEXEPTION", "SQLEXPLAIN", "SQLNOTFOUND",
            "SQLSTATE", "SQLWARNING", "SQRT", "STABILITY", "START", "STARTING",
            "STARTPOS", "START_SEGMENT", "START_SEGMENTED_?", "START_STREAM",
            "START_TRANSACTION", "STATE", "STATIC", "STATISTICS", "STATUS",
            "STDDEV", "STDEV", "STEP", "STOP", "STORE", "STRAIGHT_JOIN",
            "STRING", "STRUCTURE", "SUBMENU", "SUBSTR", "SUBSTRING", "SUBTYPE",
            "SUCCEEDS", "SUCCESFULL", "SUCCESSFULL", "SUCCESSFUL", "SUM", "SUMU", "SUPERDBA",
            "SYB_TERMINATE", "SYNONYM", "SYSDATE", "SYSSORT", "SYSTEM_USER",

            "TABLE", "TABLEDATA", "TABLES", "TEMP", "TEMPORARY", "TERMINATE",
            "TERMINATED", "TEXT", "TEXTSIZE", "THAN", "THEN", "THROUGH",
            "THRU", "TID", "TIME", "TIMESTAMP", "TIMEZONE_HOUR",
            "TIMEZONE_MINUTE", "TINYBLOB", "TINYINT", "TINYTEXT", "TO",
            "TODAY", "TOLOWER", "TOP", "TOTAL", "TOUPPER", "TP", "TRAILER",
            "TRAILING", "TRAN", "TRANS", "TRANSACTION", "TRANSACTION_HANDLE",
            "TRANSFER", "TRANSLATE", "TRANSLATION", "TREAT", "TRIGGER",
            "TRING", "TRUE", "TRUNC", "TRUNCATE", "TSEQUAL", "TYPE",

            "UID", "UNBUFFERED", "UNDER", "UNDO", "UNION", "UNIQUE", "UNKNOWN",
            "UNLISTEN", "UNLOAD", "UNLOADDATA", "UNLOADTABLE", "UNLOCK",
            "UNTIL", "UP", "UPDATE", "UPDATETEXT", "UPPER", "USAGE", "USE",
            "USED_PGS", "USER", "USING", "UTC_TIME",

            "VACUUM", "VALIDATE", "VALIDROW", "VALUE", "VALUES", "VARBINARY",
            "VARC", "VARCH", "VARCHA", "VARCHAR", "VARGRAPHIC", "VARIABLE",
            "VARIABLES", "VARIANCE", "VARYING", "VERB_TIME", "VERBOSE",
            "VERIFY", "VERSION", "VIEW",

            "WAIT", "WAITFOR", "WAITING", "WARNING", "WEEKDAY", "WHEN",
            "WHENEVER", "WHERE", "WHILE", "WINDOW", "WITH", "WITHOUT", "WORK",
            "WRAP", "WRITE", "WRITEPASS", "WRITETEXT",

            "YEAR", "YEARS",

            "ZEROFILL", "ZONE" };

    private ModelEntityChecker() {}
}