| ################################################################################ |
| # Copyright (c) 2006, 2014 Oracle. All rights reserved. |
| # This program and the accompanying materials are made available under the |
| # terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 |
| # which accompanies this distribution. |
| # The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html |
| # and the Eclipse Distribution License is available at |
| # http://www.eclipse.org/org/documents/edl-v10.php. |
| # |
| # Contributors: |
| # Oracle - initial API and implementation |
| ################################################################################ |
| |
| # AbsExpression - Grammar |
| ABS_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| ABS_EXPRESSION_MISSING_EXPRESSION = The encapsulated expression must be provided for an ABS expression. |
| ABS_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the ABS expression. |
| ABS_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the ABS expression. |
| # AbsExpression - Semantic |
| ABS_EXPRESSION_INVALID_NUMERIC_EXPRESSION = The encapsulated expression is not a valid numeric expression. |
| |
| # AbstractFromClause - Grammar |
| ABSTRACT_FROM_CLAUSE_IDENTIFICATION_VARIABLE_DECLARATION_ENDS_WITH_COMMA = The FROM clause cannot end with a comma. |
| ABSTRACT_FROM_CLAUSE_IDENTIFICATION_VARIABLE_DECLARATION_IS_MISSING_COMMA = The FROM clause has ''{0}'' and ''{1}'' that are not separated by a comma. |
| ABSTRACT_FROM_CLAUSE_MISSING_IDENTIFICATION_VARIABLE_DECLARATION = The FROM clause must defined at least one identification variable declaration. |
| # AbstractFromClause - Semantic |
| ABSTRACT_FROM_CLAUSE_INVALID_FIRST_IDENTIFICATION_VARIABLE_DECLARATION = ''{0}'' cannot be the first declaration of the FROM clause. |
| ABSTRACT_FROM_CLAUSE_WRONG_ORDER_OF_IDENTIFICATION_VARIABLE_DECLARATION = The identification variable ''{0}'' is declared after its usage. Identification variables are evaluated from left to right. |
| |
| # AbstractPathExpression - Grammar |
| ABSTRACT_PATH_EXPRESSION_CANNOT_END_WITH_COMMA = A path expression cannot end with a comma. |
| ABSTRACT_PATH_EXPRESSION_INVALID_IDENTIFICATION_VARIABLE = A path expression must start with a valid expression. |
| ABSTRACT_PATH_EXPRESSION_MISSING_IDENTIFICATION_VARIABLE = A path expression must start with an identification variable. |
| |
| # AbstractSchemaName - Grammar |
| ABSTRACT_SCHEMA_NAME_INVALID = The abstract schema type ''{0}'' is unknown. |
| # AbstractSchemaName - Semantic |
| PATH_EXPRESSION_NOT_RELATIONSHIP_MAPPING = The derived path ''{0}'' does not represent an association field. |
| |
| # AbstractSelectClause - Grammar |
| ABSTRACT_SELECT_CLAUSE_INVALID_SELECT_EXPRESSION = The select expression is not a valid expression. |
| ABSTRACT_SELECT_CLAUSE_MISSING_SELECT_EXPRESSION = The select expression is missing from the SELECT clause. |
| ABSTRACT_SELECT_CLAUSE_SELECT_EXPRESSION_ENDS_WITH_COMMA = The select expression cannot end with a comma. |
| ABSTRACT_SELECT_CLAUSE_SELECT_EXPRESSION_IS_MISSING_COMMA = The SELECT clause has ''{0}'' and ''{1}'' that are not separated by a comma. |
| ABSTRACT_SELECT_CLAUSE_SELECT_EXPRESSION_MALFORMED = The select expression is malformed. |
| |
| # AbstractSelectStatement - Grammar |
| ABSTRACT_SELECT_STATEMENT_FROM_CLAUSE_MSSING = A select statement must have a FROM clause. |
| |
| # AdditionExpression - Semantic |
| ADDITION_EXPRESSION_LEFT_EXPRESSION_WRONG_TYPE = The left side of the addition is not a valid arithmetic expression. |
| ADDITION_EXPRESSION_RIGHT_EXPRESSION_WRONG_TYPE = The right side of the addition is not a valid arithmetic expression. |
| |
| # AggregateFunction - Grammar |
| AGGREGATE_FUNCTION_WRONG_CLAUSE = The {0} function is only allowed in the SELECT, GROUP BY, ORDER BY and HAVING clauses. |
| |
| # AllOrAnyExpression - Grammar |
| ALL_OR_ANY_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| ALL_OR_ANY_EXPRESSION_MISSING_EXPRESSION = The subquery must be provided for an {0} expression. |
| ALL_OR_ANY_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the {0} expression. |
| ALL_OR_ANY_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the {0} expression. |
| ALL_OR_ANY_EXPRESSION_NOT_PART_OF_COMPARISON_EXPRESSION = The {0} expression must be part of a comparison expression. |
| |
| # ArithmeticFactor - Grammar |
| ARITHMETIC_FACTOR_MISSING_EXPRESSION = An arithmetic factor must be followed by an expression. |
| # ArithmeticFactor - Semantic |
| ARITHMETIC_FACTOR_INVALID_EXPRESSION = The expression must be an arithmetic expression. |
| |
| # ArithmeticExpression - Grammar |
| ARITHMETIC_EXPRESSION_INVALID_LEFT_EXPRESSION = The left expression is not an arithmetic expression. |
| ARITHMETIC_EXPRESSION_INVALID_RIGHT_EXPRESSION = The right expression is not an arithmetic expression. |
| ARITHMETIC_EXPRESSION_MISSING_LEFT_EXPRESSION = The left expression is missing from the arithmetic expression. |
| ARITHMETIC_EXPRESSION_MISSING_RIGHT_EXPRESSION = The right expression is missing from the arithmetic expression. |
| |
| # AvgFunction - Grammar |
| AVG_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| AVG_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the AVG expression. |
| AVG_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for an AVG expression. |
| AVG_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the AVG expression. |
| # AvgFunction - Semantic |
| AVG_FUNCTION_INVALID_NUMERIC_EXPRESSION = The encapsulated expression is not a valid numeric expression. |
| |
| # BadExpression |
| BAD_EXPRESSION_INVALID_EXPRESSION = The expression is invalid, which means it does not follow the JPQL grammar. |
| |
| # BetweenExpression - Grammar |
| BETWEEN_EXPRESSION_MISSING_EXPRESSION = The result expression is missing from the BETWEEN expression. |
| BETWEEN_EXPRESSION_MISSING_LOWER_BOUND_EXPRESSION = The lower bound expression is missing from the BETWEEN expression. |
| BETWEEN_EXPRESSION_MISSING_AND = The identifier AND is missing from the BETWEEN expression. |
| BETWEEN_EXPRESSION_MISSING_UPPER_BOUND_EXPRESSION = The upper bound expression is missing from the BETWEEN expression. |
| # BetweenExpression - Semantic |
| BETWEEN_EXPRESSION_WRONG_TYPE = The expression's type and the lower and upper bound expressions' type have to be the same type. |
| |
| # CaseExpression - Grammar |
| CASE_EXPRESSION_INVALID_JPA_VERSION = A CASE expression cannot be used in a JPQL query when the JPA platform is 1.0. |
| CASE_EXPRESSION_MISSING_ELSE_EXPRESSION = A CASE expression must have an ELSE expression. |
| CASE_EXPRESSION_MISSING_ELSE_IDENTIFIER = The identifier ELSE is missing from the CASE expression. |
| CASE_EXPRESSION_MISSING_END_IDENTIFIER = The identifier END is missing from the CASE expression. |
| CASE_EXPRESSION_MISSING_WHEN_CLAUSE = A CASE expression must define at least one WHEN clause. |
| CASE_EXPRESSION_WHEN_CLAUSES_END_WITH_COMMA = The WHEN clauses cannot end with a comma. |
| CASE_EXPRESSION_WHEN_CLAUSES_HAS_COMMA = Two WHEN clauses cannot be separated by a comma. |
| |
| # CastExpression - Grammar |
| CAST_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| CAST_EXPRESSION_INVALID_JPA_VERSION = A CAST expression is only supported by EclipseLink. |
| CAST_EXPRESSION_MISSING_DATABASE_TYPE = The database type must be specified. |
| CAST_EXPRESSION_MISSING_EXPRESSION = The encapsulated expression must be provided for a CAST expression. |
| CAST_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the CAST expression. |
| CAST_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the CAST expression. |
| |
| # CoalesceExpression - Grammar |
| COALESCE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| COALESCE_EXPRESSION_INVALID_JPA_VERSION = A COALESCE expression cannot be used in a JPQL query when the JPA platform is 1.0. |
| COALESCE_EXPRESSION_MISSING_EXPRESSION = The encapsulated expressions must be provided for a COALESCE expression. |
| COALESCE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the COALESCE expression. |
| COALESCE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the COALESCE expression. |
| |
| # CollectionExpression - Grammar |
| COLLECTION_EXPRESSION_MISSING_EXPRESSION = An expression at position {0} must be defined. |
| |
| # CollectionMemberExpression - Grammar |
| COLLECTION_MEMBER_EXPRESSION_MISSING_ENTITY_EXPRESSION = A collection member expression must define an entity expression. |
| COLLECTION_MEMBER_EXPRESSION_MISSING_COLLECTION_VALUED_PATH_EXPRESSION = A collection member expression must define a collection valued path expression. |
| # CollectionMemberExpression - Semantic |
| COLLECTION_MEMBER_EXPRESSION_EMBEDDABLE = An embeddable type is not supported. |
| |
| # CollectionMemberDeclaration - Grammar |
| COLLECTION_MEMBER_DECLARATION_MISSING_COLLECTION_VALUED_PATH_EXPRESSION = The collection-valued path expression is missing from the collection member declaration. |
| COLLECTION_MEMBER_DECLARATION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the collection member declaration. |
| COLLECTION_MEMBER_DECLARATION_MISSING_IDENTIFICATION_VARIABLE = An identification variable must be specified for a collection member declaration. |
| COLLECTION_MEMBER_DECLARATION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the collection member declaration. |
| |
| # CollectionValuedPathExpression - Semantic |
| COLLECTION_VALUED_PATH_EXPRESSION_NOT_RESOLVABLE = The collection-valued path ''{0}'' cannot be resolved to a valid association field. |
| COLLECTION_VALUED_PATH_EXPRESSION_NOT_COLLECTION_TYPE = The collection-valued path ''{0}'' must resolve to an association field. |
| |
| # ComparisonExpression - Grammar |
| COMPARISON_EXPRESSION_MISSING_LEFT_EXPRESSION = A comparison expression must define the left side of the comparison. |
| COMPARISON_EXPRESSION_MISSING_RIGHT_EXPRESSION = A comparison expression must define the right side of the comparison. |
| # ComparisonExpression - Semantic |
| COMPARISON_EXPRESSION_ASSOCIATION_FIELD = The relationship mapping ''{0}'' cannot be used in conjunction with the {1} operator. |
| COMPARISON_EXPRESSION_BASIC_FIELD = The basic mapping ''{0}'' cannot be used in conjunction with the {1} operator. |
| COMPARISON_EXPRESSION_IDENTIFICATION_VARIABLE = The identification variable ''{0}'' cannot be used in conjunction with the {1} operator. |
| COMPARISON_EXPRESSION_WRONG_COMPARISON_TYPE = The left and right expressions' type must be of the same type. |
| |
| # ConcatExpression - Grammar |
| CONCAT_EXPRESSION_INVALID_EXPRESSION = The expression ''{0}'' is not valid expression. |
| CONCAT_EXPRESSION_MISSING_EXPRESSION = The encapsulated expression is missing from the CONCAT expression. |
| CONCAT_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the CONCAT expression. |
| CONCAT_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the CONCAT expression. |
| # ConcatExpression - Semantic |
| CONCAT_EXPRESSION_EXPRESSION_WRONG_TYPE = The expression ''{0}'' is not a String. |
| |
| # ConstructorExpression - Grammar |
| CONSTRUCTOR_EXPRESSION_CONSTRUCTOR_ITEM_ENDS_WITH_COMMA = The constructor items cannot end with a comma. |
| CONSTRUCTOR_EXPRESSION_CONSTRUCTOR_ITEM_IS_MISSING_COMMA = The constructor expression has two constructor items (''{0}'' and ''{1}'') that are not separated by a comma. |
| CONSTRUCTOR_EXPRESSION_MISSING_CONSTRUCTOR_ITEM = A constructor expression must define at least one constructor item. |
| CONSTRUCTOR_EXPRESSION_MISSING_CONSTRUCTOR_NAME = The fully qualified class name must be specified. |
| CONSTRUCTOR_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the constructor expression. |
| CONSTRUCTOR_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the constructor expression. |
| # ConstructorExpression - Semantic |
| CONSTRUCTOR_EXPRESSION_UNDEFINED_CONSTRUCTOR = No constructors can be found that match the argument types. |
| CONSTRUCTOR_EXPRESSION_UNKNOWN_TYPE = ''{0}'' cannot be resolved to a type. |
| |
| # CountFunction - Grammar |
| COUNT_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| COUNT_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for a COUNT expression. |
| COUNT_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the COUNT expression. |
| COUNT_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the COUNT expression. |
| # CountFunction - Semantic |
| COUNT_FUNCTION_DISTINCT_EMBEDDABLE = The use of DISTINCT is not supported for arguments of embeddable types. |
| |
| # DatabaseType - Grammar |
| DATABASE_TYPE_INVALID_FIRST_EXPRESSION = The first argument is not a valid precision/length value. |
| DATABASE_TYPE_INVALID_SECOND_EXPRESSION = The second argument is not a valid scale value. |
| DATABASE_TYPE_MISSING_COMMA = The comma separating the length and precision is missing. |
| DATABASE_TYPE_MISSING_FIRST_EXPRESSION = The precision/length value is missing. |
| DATABASE_TYPE_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the database type expression. |
| DATABASE_TYPE_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the database type expression. |
| DATABASE_TYPE_MISSING_SECOND_EXPRESSION = The scale value is missing. |
| |
| # DateTime - Grammar |
| DATE_TIME_JDBC_ESCAPE_FORMAT_INVALID_SPECIFICATION = The JDBC escape format does not start with either 'd', 't' or 'ts'. |
| DATE_TIME_JDBC_ESCAPE_FORMAT_MISSING_CLOSE_QUOTE = The JDBC escape format is missing the close quote. |
| DATE_TIME_JDBC_ESCAPE_FORMAT_MISSING_OPEN_QUOTE = The JDBC escape format is missing the open quote. |
| DATE_TIME_JDBC_ESCAPE_FORMAT_MISSING_RIGHT_CURLY_BRACE = The JDBC escape format is missing the right curly brace. |
| |
| # DeleteClause - Grammar |
| DELETE_CLAUSE_FROM_MISSING = The identifier FROM is missing from the DELETE FROM clause. |
| DELETE_CLAUSE_MULTIPLE_RANGE_VARIABLE_DECLARATION = Only one entity abstract schema type can be defined. |
| DELETE_CLAUSE_RANGE_VARIABLE_DECLARATION_MALFORMED = The entity abstract schema type declaration is malformed. |
| DELETE_CLAUSE_RANGE_VARIABLE_DECLARATION_MISSING = A DELETE clause must define an entity abstract schema type. |
| |
| # DivisionExpression - Semantic |
| DIVISION_EXPRESSION_LEFT_EXPRESSION_WRONG_TYPE = The left side of the division is not a valid arithmetic expression. |
| DIVISION_EXPRESSION_RIGHT_EXPRESSION_WRONG_TYPE = The right side of the division is not a valid arithmetic expression. |
| |
| # EncapsulatedIdentificationVariableExpression - Semantic |
| ENCAPSULATED_IDENTIFICATION_VARIABLE_EXPRESSION_NOT_MAP_VALUED = The {0} operator may only be applied to identification variables that correspond to map-valued associations or map-valued element collections. |
| |
| # EmptyCollectionComparisonExpression - Grammar |
| EMPTY_COLLECTION_COMPARISON_EXPRESSION_MISSING_EXPRESSION = The collection valued path expression must be defined. |
| |
| # EntityTypeLiteral - Semantic |
| ENTITY_TYPE_LITERAL_INVALID_JPA_VERSION = An entity name cannot be used as an entity type literal in a JPQL query when the JPA platform is 1.0. |
| ENTITY_TYPE_LITERAL_NOT_RESOLVABLE = ''{0}'' cannot be resolved to a type. |
| |
| # EntryExpression - Grammar |
| ENTRY_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| ENTRY_EXPRESSION_MISSING_EXPRESSION = An identification variable must be provided for an ENTRY expression. |
| ENTRY_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the ENTRY expression. |
| ENTRY_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the ENTRY expression. |
| ENTRY_EXPRESSION_INVALID_JPA_VERSION = An ENTRY expression cannot be used in a JPQL query when the JPA platform is 1.0. |
| |
| # ExistsExpression - Grammar |
| EXISTS_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| EXISTS_EXPRESSION_MISSING_EXPRESSION = A subquery must be provided for an EXISTS expression. |
| EXISTS_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the EXISTS expression. |
| EXISTS_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the EXISTS expression. |
| |
| # ExtractExpression - Grammar |
| EXTRACT_EXPRESSION_INVALID_EXPRESSION = The date expression is not a valid expression. |
| EXTRACT_EXPRESSION_INVALID_JPA_VERSION = An EXTRACT expression is only supported by EclipseLink. |
| EXTRACT_EXPRESSION_MISSING_DATE_PART = The date part must be specified. |
| EXTRACT_EXPRESSION_MISSING_EXPRESSION = The date expression is missing from the EXTRACT expression. |
| EXTRACT_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the EXTRACT expression. |
| EXTRACT_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the EXTRACT expression. |
| |
| # FunctionExpression - Grammar |
| FUNCTION_EXPRESSION_HAS_EXPRESSION = The function {0} should not have any argument. |
| FUNCTION_EXPRESSION_INVALID_EXPRESSION = The function {0}''s argument is not valid. |
| FUNCTION_EXPRESSION_INVALID_JPA_VERSION = A FUNCTION expression can only be used in a JPQL query when the JPA platform is 2.1. |
| FUNCTION_EXPRESSION_MISSING_EXPRESSION = The function {0}''s argument must be specified. |
| FUNCTION_EXPRESSION_MISSING_FUNCTION_NAME = The function name must be specified. |
| FUNCTION_EXPRESSION_MISSING_ONE_EXPRESSION = The function {0} must have one argument specified. |
| FUNCTION_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the function {0}. |
| FUNCTION_EXPRESSION_MORE_THAN_ONE_EXPRESSION = The function {0} has more than one argument, can only specify one argument. |
| # FunctionExpression - Semantic |
| FUNCTION_EXPRESSION_UNKNOWN_COLUMN = The column {0} cannot be found on the table {1}. |
| |
| # GroupByClause - Grammar |
| GROUP_BY_CLAUSE_GROUP_BY_ITEM_ENDS_WITH_COMMA = The select expression cannot end with a comma. |
| GROUP_BY_CLAUSE_GROUP_BY_ITEM_IS_MISSING_COMMA = The GROUP BY clause has ''{0}'' and ''{1}'' that are not separated by a comma. |
| GROUP_BY_CLAUSE_GROUP_BY_ITEM_MISSING = The grouping item is missing from the GROUP BY clause. |
| |
| # HavingClause - Grammar |
| HAVING_CLAUSE_INVALID_CONDITIONAL_EXPRESSION = The expression is not a valid conditional expression. |
| HAVING_CLAUSE_MISSING_CONDITIONAL_EXPRESSION = The conditional expression is missing from the HAVING clause. |
| |
| # HermesParser - Validation |
| HERMES_PARSER_GRAMMAR_VALIDATOR_ERROR_MESSAGE = Syntax error parsing [{0}]. {1} |
| HERMES_PARSER_SEMANTIC_VALIDATOR_ERROR_MESSAGE = Problem compiling [{0}]. {1} |
| HERMES_PARSER_UNEXPECTED_EXCEPTION_ERROR_MESSAGE = Internal problem encountered while compiling [{0}]. |
| |
| # IdentificationVariable - Grammar |
| IDENTIFICATION_VARIABLE_INVALID_DUPLICATE = The identification variable ''{0}'' cannot be declared more than once. |
| IDENTIFICATION_VARIABLE_INVALID_JAVA_IDENTIFIER = The identification variable ''{0}'' is not following the rules for a Java identifier. |
| IDENTIFICATION_VARIABLE_INVALID_RESERVED_WORD = The identification variable ''{0}'' cannot be a reserved word. |
| # IdentificationVariable - Semantic |
| IDENTIFICATION_VARIABLE_ENTITY_NAME = An identification variable must not have the same name as any entity in the same persistence unit. |
| IDENTIFICATION_VARIABLE_INVALID_NOT_DECLARED = The identification variable ''{0}'' is not defined in the FROM clause. |
| |
| # IdentificationVariableDeclaration - Grammar |
| IDENTIFICATION_VARIABLE_DECLARATION_JOINS_END_WITH_COMMA = The JOIN expressions cannot end with a comma. |
| IDENTIFICATION_VARIABLE_DECLARATION_JOINS_HAS_COMMA = JOIN expressions cannot be separated by a comma. |
| IDENTIFICATION_VARIABLE_DECLARATION_MISSING_RANGE_VARIABLE_DECLARATION = The range variable declaration must be specified. |
| |
| # IndexExpression - Grammar |
| INDEX_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| INDEX_EXPRESSION_INVALID_JPA_VERSION = An INDEX expression cannot be used in a JPQL query when the JPA platform is 1.0. |
| INDEX_EXPRESSION_MISSING_EXPRESSION = An identification variable must be provided for an INDEX expression. |
| INDEX_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the INDEX expression. |
| INDEX_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the INDEX expression. |
| # IndexExpression - Semantic |
| INDEX_EXPRESSION_WRONG_VARIABLE = The identification variable ''{0}'' does not represent an association or element collection. |
| |
| # InExpression - Grammar |
| IN_EXPRESSION_ITEM_ENDS_WITH_COMMA = The list of items cannot end with a comma. |
| IN_EXPRESSION_ITEM_INVALID_EXPRESSION = The expression at index {0} is not a valid expression. |
| IN_EXPRESSION_ITEM_IS_MISSING_COMMA = The IN expression has ''{0}'' and ''{1}'' that are not separated by a comma. |
| IN_EXPRESSION_INVALID_EXPRESSION = The IN expression does not have a valid left expression. |
| IN_EXPRESSION_MISSING_EXPRESSION = The IN expression is missing the left expression. |
| IN_EXPRESSION_MISSING_IN_ITEMS = A least one item must be specified for the IN expression. |
| IN_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the IN expression. |
| IN_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the IN expression. |
| # InExpression - Semantic |
| IN_EXPRESSION_INVALID_ITEM_COUNT = The number of items in the nested array must match the number of subquery select items. |
| |
| # InputParameter - Grammar |
| INPUT_PARAMETER_JAVA_IDENTIFIER = The named input parameter ''{0}'' is not following the rules for a Java identifier. |
| INPUT_PARAMETER_MISSING_PARAMETER = The parameter value is missing from the input parameter. |
| INPUT_PARAMETER_MIXTURE = Named and positional input parameters must not be mixed in a single query. |
| INPUT_PARAMETER_NOT_INTEGER = The positional input parameter ''{0}'' cannot use non-Integer characters. |
| INPUT_PARAMETER_SMALLER_THAN_ONE = The number used for the positional input parameter ''{0}'' must be greater than 0. |
| INPUT_PARAMETER_WRONG_CLAUSE_DECLARATION = Input parameters can only be used in the WHERE clause or HAVING clause of a query. |
| |
| # Join - Grammar |
| JOIN_INVALID_IDENTIFIER = The JOIN identifier is not valid. |
| JOIN_INVALID_JOIN_ASSOCIATION_PATH = The join association path is not a valid expression. |
| JOIN_MISSING_IDENTIFICATION_VARIABLE = An identification variable must be defined for a JOIN expression. |
| JOIN_MISSING_JOIN_ASSOCIATION_PATH = The join association path is missing from the JOIN expression. |
| |
| # JoinFetch - Grammar |
| JOIN_FETCH_INVALID_IDENTIFICATION = JOIN FETCH expressions cannot be defined with an identification variable. |
| JOIN_FETCH_MISSING_IDENTIFICATION_VARIABLE = An identification variable must be defined for a JOIN FETCH expression. |
| JOIN_FETCH_MISSING_JOIN_ASSOCIATION_PATH = The join association path is missing from the JOIN FETCH expression. |
| JOIN_FETCH_WRONG_CLAUSE_DECLARATION = JOIN FETCH expressions cannot be used in a FROM clause of a subquery. |
| |
| # JPQLExpression - Grammar |
| JPQL_EXPRESSION_INVALID_QUERY = The query does not start with a valid identifier, has to be either SELECT, UPDATE or DELETE FROM. |
| JPQL_EXPRESSION_UNKNOWN_ENDING = The query contains a malformed ending. |
| |
| # KeyExpression - Grammar |
| KEY_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| KEY_EXPRESSION_INVALID_JPA_VERSION = A KEY expression cannot be used in a JPQL query when the JPA platform is 1.0. |
| KEY_EXPRESSION_MISSING_EXPRESSION = The identification variable must be provided for an ABS expression. |
| KEY_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the ABS expression. |
| KEY_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the ABS expression. |
| |
| # LengthExpression - Grammar |
| LENGTH_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| LENGTH_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a LENGTH expression. |
| LENGTH_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the LENGTH expression. |
| LENGTH_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the LENGTH expression. |
| # LikeExpression - Semantic |
| LENGTH_EXPRESSION_WRONG_TYPE = The encapsulated expression is not of string type. |
| |
| # LikeExpression - Grammar |
| LIKE_EXPRESSION_INVALID_ESCAPE_CHARACTER = {0} is not a valid escape character. |
| LIKE_EXPRESSION_MISSING_ESCAPE_CHARACTER = The escape character is missing from the LIKE expression. |
| LIKE_EXPRESSION_MISSING_PATTERN_VALUE = The pattern value is missing from the LIKE expression. |
| LIKE_EXPRESSION_MISSING_STRING_EXPRESSION = The string expression is missing from the LIKE expression. |
| |
| # LocateExpression - Grammar |
| LOCATE_EXPRESSION_INVALID_FIRST_EXPRESSION = The first argument is not a valid expression. |
| LOCATE_EXPRESSION_INVALID_SECOND_EXPRESSION = The second argument is not a valid expression. |
| LOCATE_EXPRESSION_INVALID_THIRD_EXPRESSION = The third argument is not a valid expression. |
| LOCATE_EXPRESSION_MISSING_FIRST_EXPRESSION = The first argument is missing from the LOCATE expression. |
| LOCATE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the LOCATE expression. |
| LOCATE_EXPRESSION_MISSING_FIRST_COMMA = The first comma is missing from the LOCATE expression. |
| LOCATE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the LOCATE expression. |
| LOCATE_EXPRESSION_MISSING_SECOND_COMMA = The second comma is missing from the LOCATE expression. |
| LOCATE_EXPRESSION_MISSING_SECOND_EXPRESSION = The second argument is missing from the LOCATE expression. |
| LOCATE_EXPRESSION_MISSING_THIRD_EXPRESSION = The third argument is missing from the LOCATE expression. |
| # LocateExpression - Semantic |
| LOCATE_EXPRESSION_FIRST_EXPRESSION_WRONG_TYPE = The first expression is not of string type. |
| LOCATE_EXPRESSION_SECOND_EXPRESSION_WRONG_TYPE = The second expression is not of string type. |
| LOCATE_EXPRESSION_THIRD_EXPRESSION_WRONG_TYPE = The third encapsulated expression is not of numeric type. |
| |
| # LogicalExpression - Grammar |
| LOGICAL_EXPRESSION_INVALID_LEFT_EXPRESSION = The left expression is not a valid expression. |
| LOGICAL_EXPRESSION_INVALID_RIGHT_EXPRESSION = The right expression is not a valid expression. |
| LOGICAL_EXPRESSION_MISSING_LEFT_EXPRESSION = The left expression is missing from the logical expression. |
| LOGICAL_EXPRESSION_MISSING_RIGHT_EXPRESSION = The right expression is missing from the logical expression. |
| |
| # LowerExpression - Grammar |
| LOWER_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| LOWER_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a LOWER expression. |
| LOWER_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the LOWER expression. |
| LOWER_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the LOWER expression. |
| # UpperExpression - Semantic |
| LOWER_EXPRESSION_WRONG_TYPE = The expression is not a String. |
| |
| # MaxFunction - Grammar |
| MAX_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| MAX_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for a MAX expression. |
| MAX_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the MAX expression. |
| MAX_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the MAX expression. |
| |
| # MinFunction - Grammar |
| MIN_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| MIN_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for a MIN expression. |
| MIN_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the MIN expression. |
| MIN_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the MIN expression. |
| |
| # ModExpression - Grammar |
| MOD_EXPRESSION_INVALID_FIRST_EXPRESSION = The first argument is not a valid expression. |
| MOD_EXPRESSION_INVALID_SECOND_EXPRESSION = The second argument is not a valid expression. |
| MOD_EXPRESSION_MISSING_COMMA = The comma is missing from the MOD expression. |
| MOD_EXPRESSION_MISSING_FIRST_EXPRESSION = The first argument is missing from the MOD expression. |
| MOD_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the MOD expression. |
| MOD_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the MOD expression. |
| MOD_EXPRESSION_MISSING_SECOND_EXPRESSION = The second argument is missing from the MOD expression. |
| # ModExpression - Semantic |
| MOD_EXPRESSION_FIRST_EXPRESSION_WRONG_TYPE = The first expression is not an Integer. |
| MOD_EXPRESSION_SECOND_EXPRESSION_WRONG_TYPE = The second expression is not an Integer. |
| |
| # MultiplicationExpression - Semantic |
| MULTIPLICATION_EXPRESSION_LEFT_EXPRESSION_WRONG_TYPE = The left side of the multiplication is not a valid arithmetic expression. |
| MULTIPLICATION_EXPRESSION_RIGHT_EXPRESSION_WRONG_TYPE = The right side of the multiplication is not a valid arithmetic expression. |
| |
| # NotExpression - Grammar |
| NOT_EXPRESSION_MISSING_EXPRESSION = The expression is missing after the identifier NOT. |
| # NotExpression - Semantic |
| NOT_EXPRESSION_WRONG_TYPE = The expression is not of boolean type. |
| # NullComparisonExpression - Grammar |
| NULL_COMPARISON_EXPRESSION_MISSING_EXPRESSION = The expression is missing from the null comparison expression. |
| # NullComparisonExpression - Semantic |
| NULL_COMPARISON_EXPRESSION_INVALID_TYPE = ''{0}'' cannot be resolved to an embeddable. |
| |
| # NullIfExpression - Grammar |
| NULLIF_EXPRESSION_INVALID_FIRST_EXPRESSION = The first argument is not a valid expression. |
| NULLIF_EXPRESSION_INVALID_JPA_VERSION = A NULLIF expression cannot be used in a JPQL query when the JPA platform is 1.0. |
| NULLIF_EXPRESSION_INVALID_SECOND_EXPRESSION = The second argument is not a valid expression. |
| NULLIF_EXPRESSION_MISSING_COMMA = The comma is missing from the NULLIF expression. |
| NULLIF_EXPRESSION_MISSING_FIRST_EXPRESSION = The first argument is missing from the NULLIF expression. |
| NULLIF_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the NULLIF expression. |
| NULLIF_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the NULLIF expression. |
| NULLIF_EXPRESSION_MISSING_SECOND_EXPRESSION = The second argument is missing from the NULLIF expression. |
| |
| # NumericLiteral - Grammar |
| NUMERIC_LITERAL_INVALID = ''{0}'' is not a valid numeric value. |
| |
| # ObjectByItem - Grammar |
| ORDER_BY_ITEM_INVALID_EXPRESSION = The order by item is not a valid expression. |
| ORDER_BY_ITEM_MISSING_EXPRESSION = An order by item must be specified. |
| |
| # ObjectExpression - Grammar |
| OBJECT_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| OBJECT_EXPRESSION_MISSING_EXPRESSION = An identification variable must be provided for an OBJECT expression. |
| OBJECT_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the OBJECT expression. |
| OBJECT_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the OBJECT expression. |
| |
| # OnClause - Grammar |
| ON_CLAUSE_INVALID_CONDITIONAL_EXPRESSION = The expression is not a valid conditional expression. |
| ON_CLAUSE_MISSING_CONDITIONAL_EXPRESSION = The conditional expression is missing from the JOIN condition. |
| |
| # OrderByClause - Grammar |
| ORDER_BY_CLAUSE_ORDER_BY_ITEM_ENDS_WITH_COMMA = The select expression cannot end with a comma. |
| ORDER_BY_CLAUSE_ORDER_BY_ITEM_IS_MISSING_COMMA = The ORDER BY clause has ''{0}'' and ''{1}'' that are not separated by a comma. |
| ORDER_BY_CLAUSE_ORDER_BY_ITEM_MISSING = The ordering item is missing from the ORDER BY clause. |
| |
| # RangeVariableDeclaration - Grammar |
| RANGE_VARIABLE_DECLARATION_MISSING_ROOT_OBJECT = A "root object" must be specified. |
| RANGE_VARIABLE_DECLARATION_INVALID_ROOT_OBJECT = A "root object" must be specified. |
| RANGE_VARIABLE_DECLARATION_MISSING_IDENTIFICATION_VARIABLE = An identification variable must be provided for a range variable declaration. |
| |
| # RegexpExpression - Grammar |
| REGEXP_EXPRESSION_INVALID_JPA_VERSION = A REGEXP expression is only supported by EclipseLink. |
| REGEXP_EXPRESSION_INVALID_PATTERN_VALUE = The pattern value is not a valid expression. |
| REGEXP_EXPRESSION_INVALID_STRING_EXPRESSION = The string expression is not a valid expression. |
| REGEXP_EXPRESSION_MISSING_PATTERN_VALUE = The pattern value must be specified. |
| REGEXP_EXPRESSION_MISSING_STRING_EXPRESSION = The string expression must be specified. |
| |
| # ResultVariable - Grammar |
| RESULT_VARIABLE_INVALID_JPA_VERSION = A result variable cannot be used in a JPQL query when the JPA platform is 1.0. |
| RESULT_VARIABLE_MISSING_SELECT_EXPRESSION = The select item is missing from the result variable declaration. |
| RESULT_VARIABLE_MISSING_RESULT_VARIABLE = The result variable is missing from the select item declaration. |
| |
| # SimpleSelectClause - Grammar |
| SIMPLE_SELECT_CLAUSE_NOT_SINGLE_EXPRESSION = Only one expression can be declared in a SELECT clause of a subquery. |
| |
| # SizeExpression - Grammar |
| SIZE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| SIZE_EXPRESSION_MISSING_EXPRESSION = A collection-valued path expression must be provided for a SIZE expression. |
| SIZE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the SIZE expression. |
| SIZE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the SIZE expression. |
| |
| # SqrtExpression - Grammar |
| SQRT_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| SQRT_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a SQRT expression. |
| SQRT_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the SQRT expression. |
| SQRT_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the SQRT expression. |
| # SqrtExpression - Semantic |
| SQRT_EXPRESSION_WRONG_TYPE = The expression is not a numeric type. |
| |
| # StateFieldPathExpression - Semantic |
| STATE_FIELD_PATH_EXPRESSION_ASSOCIATION_FIELD = The association field ''{0}'' cannot be used as a state field path. |
| STATE_FIELD_PATH_EXPRESSION_BASIC_FIELD = The basic field ''{0}'' cannot be used as a state field path. |
| STATE_FIELD_PATH_EXPRESSION_COLLECTION_TYPE = The state field path ''{0}'' cannot be resolved to a collection type. |
| STATE_FIELD_PATH_EXPRESSION_INVALID_ENUM_CONSTANT = ''{0}'' cannot be resolved to an Enum constant. |
| STATE_FIELD_PATH_EXPRESSION_NO_MAPPING = No mapping is associated with the state field path ''{0}''. |
| STATE_FIELD_PATH_EXPRESSION_NOT_RESOLVABLE = The state field path ''{0}'' cannot be resolved to a valid type. |
| STATE_FIELD_PATH_EXPRESSION_UNKNOWN_COLUMN = The column {0} cannot be found on the table {1}. |
| |
| # StringLiteral - Grammar |
| STRING_LITERAL_MISSING_CLOSING_QUOTE = The string literal is missing the closing quote. |
| |
| # SubExpression - Grammar |
| SUB_EXPRESSION_MISSING_EXPRESSION = The encapsulated expression is missing. |
| SUB_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the sub-expression. |
| |
| # SubtractionExpression - Semantic |
| SUBTRACTION_EXPRESSION_LEFT_EXPRESSION_WRONG_TYPE = The left side of the subtraction is not a valid arithmetic expression. |
| SUBTRACTION_EXPRESSION_RIGHT_EXPRESSION_WRONG_TYPE = The right side of the subtraction is not a valid arithmetic expression. |
| |
| # SubstringExpression - Grammar |
| SUBSTRING_EXPRESSION_INVALID_FIRST_EXPRESSION = The first argument is not a valid expression. |
| SUBSTRING_EXPRESSION_INVALID_SECOND_EXPRESSION = The second argument is not a valid expression. |
| SUBSTRING_EXPRESSION_INVALID_THIRD_EXPRESSION = The third argument is not a valid expression. |
| SUBSTRING_EXPRESSION_MISSING_FIRST_COMMA = The first comma is missing from the SUBSTRING expression. |
| SUBSTRING_EXPRESSION_MISSING_FIRST_EXPRESSION = The first argument is missing from the SUBSTRING expression. |
| SUBSTRING_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the SUBSTRING expression. |
| SUBSTRING_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the SUBSTRING expression. |
| SUBSTRING_EXPRESSION_MISSING_SECOND_COMMA = The second comma is missing from the SUBSTRING expression. |
| SUBSTRING_EXPRESSION_MISSING_SECOND_EXPRESSION = The second argument is missing from the SUBSTRING expression. |
| SUBSTRING_EXPRESSION_MISSING_THIRD_EXPRESSION = The third argument is missing from the SUBSTRING expression. |
| # SubstringExpression - Semantic |
| SUBSTRING_EXPRESSION_FIRST_EXPRESSION_WRONG_TYPE = The first argument is not a String value. |
| SUBSTRING_EXPRESSION_SECOND_EXPRESSION_WRONG_TYPE = The second argument is not an integer value. |
| SUBSTRING_EXPRESSION_THIRD_EXPRESSION_WRONG_TYPE = The third argument is not an integer value. |
| |
| # SumFunction - Grammar |
| SUM_FUNCTION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| SUM_FUNCTION_MISSING_EXPRESSION = The encapsulated expression must be provided for a SUM expression. |
| SUM_FUNCTION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the SUM expression. |
| SUM_FUNCTION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the SUM expression. |
| # SumFunction - Semantic |
| SUM_FUNCTION_WRONG_TYPE = The argument must be numeric. |
| |
| # TableExpression - Grammar |
| TABLE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid table name. |
| TABLE_EXPRESSION_MISSING_EXPRESSION = The table name must be provided for an TABLE expression. |
| TABLE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the TABLE expression. |
| TABLE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the TABLE expression. |
| # TableExpression - Semantic |
| TABLE_EXPRESSION_INVALID_TABLE_NAME = The table ''{0}'' does not exist on the database. |
| |
| # TableVariableDeclaration - Grammar |
| TABLE_VARIABLE_DECLARATION_INVALID_JPA_VERSION = A table variable declaration can only be used when the platform is EclipseLink. |
| TABLE_VARIABLE_DECLARATION_MISSING_IDENTIFICATION_VARIABLE = An identification variable must be provided for a table variable declaration. |
| |
| # TreatExpression - Grammar |
| TREAT_EXPRESSION_INVALID_JPA_PLATFORM = A TREAT expression can only be used when the platform is EclipseLink. |
| |
| # TrimExpression - Grammar |
| TRIM_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| TRIM_EXPRESSION_INVALID_TRIM_CHARACTER = The trim character should be a single-character string literal or a character-valued input parameter (i.e., char or Character). |
| TRIM_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a TRIM expression. |
| TRIM_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the TRIM expression. |
| TRIM_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the TRIM expression. |
| TRIM_EXPRESSION_NOT_SINGLE_STRING_LITERAL = The trim character should be a single-character string literal. |
| |
| # TypeExpression - Grammar |
| TYPE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| TYPE_EXPRESSION_INVALID_JPA_VERSION = A TYPE expression cannot be used in a JPQL query when the JPA platform is 1.0. |
| TYPE_EXPRESSION_MISSING_EXPRESSION = An identification variable or a path expression must be provided for a TYPE expression. |
| TYPE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the TYPE expression. |
| TYPE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the TYPE expression. |
| |
| # UnionClause - Grammar |
| UNION_CLAUSE_INVALID_JPA_VERSION = A union clause is only supported by EclipseLink. |
| UNION_CLAUSE_MISSING_EXPRESSION = The query is missing from the UNION clause. |
| |
| # UpdateClause - Grammar |
| UPDATE_CLAUSE_MISSING_RANGE_VARIABLE_DECLARATION = The range variable declaration is missing from the UPDATE clause. |
| UPDATE_CLAUSE_MISSING_SET = The SET identifier is missing from the UPDATE clause. |
| UPDATE_CLAUSE_MISSING_UPDATE_ITEMS = At least one update item must be specified for an UPDATE clause. |
| UPDATE_CLAUSE_UPDATE_ITEM_ENDS_WITH_COMMA = The update item cannot end with a comma. |
| UPDATE_CLAUSE_UPDATE_ITEM_IS_MISSING_COMMA = The UPDATE clause has ''{0}'' and ''{1}'' that are not separated by a comma. |
| |
| # UpdateItem - Grammar |
| UPDATE_ITEM_MISSING_EQUAL_SIGN = The equal sign must be specified. |
| UPDATE_ITEM_MISSING_NEW_VALUE = The new value must be specified. |
| UPDATE_ITEM_MISSING_STATE_FIELD_PATH_EXPRESSION = The state field path expression is missing. |
| # UpdateItem - Semantic |
| UPDATE_ITEM_NOT_ASSIGNABLE = Type mismatch: cannot convert from {0} to {1}. |
| UPDATE_ITEM_NOT_RESOLVABLE = The state field cannot be resolved. |
| UPDATE_ITEM_NULL_NOT_ASSIGNABLE_TO_PRIMITIVE = NULL cannot be assigned to a primitive value. |
| UPDATE_ITEM_RELATIONSHIP_PATH_EXPRESSION = An association field cannot be used in an update item's path expression. |
| |
| # UpperExpression - Grammar |
| UPPER_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| UPPER_EXPRESSION_MISSING_EXPRESSION = An expression must be provided for a UPPER expression. |
| UPPER_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the UPPER expression. |
| UPPER_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the UPPER expression. |
| # UpperExpression - Semantic |
| UPPER_EXPRESSION_WRONG_TYPE = The expression is not a String. |
| |
| # ValueExpression - Grammar |
| VALUE_EXPRESSION_INVALID_EXPRESSION = The encapsulated expression is not a valid expression. |
| VALUE_EXPRESSION_INVALID_JPA_VERSION = A VALUE expression cannot be used in a JPQL query when the JPA platform is 1.0. |
| VALUE_EXPRESSION_MISSING_EXPRESSION = An identification variable must be provided for a VALUE expression. |
| VALUE_EXPRESSION_MISSING_LEFT_PARENTHESIS = The left parenthesis is missing from the VALUE expression. |
| VALUE_EXPRESSION_MISSING_RIGHT_PARENTHESIS = The right parenthesis is missing from the VALUE expression. |
| |
| # WhenClause - Grammar |
| WHEN_CLAUSE_MISSING_THEN_EXPRESSION = A conditional expression must be provided for a WHEN clause. |
| WHEN_CLAUSE_MISSING_THEN_IDENTIFIER = The identifier THEN is missing from the WHEN clause. |
| WHEN_CLAUSE_MISSING_WHEN_EXPRESSION = A WHEN expression must be provided for a WHEN clause. |
| |
| # WhereClause - Grammar |
| WHERE_CLAUSE_INVALID_CONDITIONAL_EXPRESSION = The expression is not a valid conditional expression. |
| WHERE_CLAUSE_MISSING_CONDITIONAL_EXPRESSION = The conditional expression is missing from the WHERE clause. |