| /******************************************************************************* |
| * 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() {} |
| } |
| |
