| /* |
| * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Oracle - initial API and implementation from Oracle TopLink |
| package org.eclipse.persistence.exceptions; |
| |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.Vector; |
| |
| import org.eclipse.persistence.exceptions.i18n.ExceptionMessageGenerator; |
| |
| /** |
| * <P><B>Purpose</B>: EJBQL parsing and resolution problems will raise this exception |
| */ |
| public class JPQLException extends EclipseLinkException { |
| public static final int recognitionException = 8001; |
| public static final int generalParsingException = 8002; |
| public static final int classNotFoundException = 8003; |
| public static final int aliasResolutionException = 8004; |
| public static final int resolutionClassNotFoundException = 8005; |
| public static final int missingDescriptorException = 8006; |
| public static final int missingMappingException = 8007; |
| public static final int invalidContextKeyException = 8008; |
| public static final int expressionNotSupported = 8009; |
| public static final int generalParsingException2 = 8010; |
| public static final int invalidCollectionMemberDecl = 8011; |
| public static final int notYetImplemented = 8012; |
| public static final int constructorClassNotFound = 8013; |
| public static final int invalidSizeArgument = 8014; |
| public static final int invalidEnumLiteral = 8015; |
| public static final int invalidSelectForGroupByQuery = 8016; |
| public static final int invalidHavingExpression = 8017; |
| public static final int invalidMultipleUseOfSameParameter = 8018; |
| public static final int multipleVariableDeclaration = 8019; |
| public static final int invalidFunctionArgument = 8020; |
| public static final int expectedOrderableOrderByItem = 8021; |
| public static final int invalidExpressionArgument = 8022; |
| public static final int syntaxError = 8023; |
| public static final int syntaxErrorAt = 8024; |
| public static final int unexpectedToken = 8025; |
| public static final int unexpectedChar = 8026; |
| public static final int expectedCharFound = 8027; |
| public static final int unexpectedEOF = 8028; |
| public static final int invalidNavigation = 8029; |
| public static final int unknownAttribute = 8030; |
| public static final int unsupportJoinArgument = 8031; |
| public static final int invalidSetClauseTarget = 8032; |
| public static final int invalidSetClauseNavigation = 8033; |
| /** |
| * @see JPQLException#entityTypeNotFound(String, String) |
| */ |
| public static final int entityTypeNotFound = 8034; |
| public static final int invalidEnumEqualExpression = 8035; |
| public static final int invalidCollectionNavigation = 8036; |
| public static final int entityTypeNotFound2 = 8037; |
| public static final int resolutionClassNotFoundException2 = 8038; |
| public static final int variableCannotHaveMapKey = 8039; |
| public static final int nonExistantOrderByAlias = 8040; |
| public static final int indexOnlyAllowedOnVariable = 8041; |
| |
| public Collection internalExceptions = null; |
| |
| /** |
| * INTERNAL |
| * Only TopLink can throw and create these excpetions |
| */ |
| protected JPQLException() { |
| super(); |
| } |
| |
| /** |
| * INTERNAL |
| * Only TopLink can throw and create these excpetions |
| */ |
| public JPQLException(String theMessage) { |
| super(theMessage); |
| } |
| |
| /** |
| * INTERNAL |
| * Only TopLink can throw and create these excpetions |
| */ |
| public JPQLException(String message, Exception internalException) { |
| super(message, internalException); |
| } |
| |
| /** |
| * INTERNAL |
| * Only TopLink can throw and create these excpetions |
| */ |
| protected JPQLException(String message, Exception internalException, int theErrorCode) { |
| this(message, internalException); |
| this.setErrorCode(theErrorCode); |
| } |
| |
| /** |
| * INTERNAL |
| * Create an exception to wrap the recognition exception thrown |
| */ |
| public static JPQLException recognitionException(String theEjbql, String theMessage) { |
| Object[] args = { theEjbql, theMessage }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, recognitionException, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(recognitionException); |
| return exception; |
| } |
| |
| /** |
| * INTERNAL |
| * Create an exception to wrap a general parsing exception |
| */ |
| public static JPQLException generalParsingException(String theEjbql, Exception theException) { |
| Object[] args = { theEjbql, theException.getMessage() }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, generalParsingException, args); |
| JPQLException exception = new JPQLException(message, theException, generalParsingException); |
| exception.setErrorCode(generalParsingException); |
| return exception; |
| } |
| |
| /** |
| * INTERNAL |
| * Create an exception to wrap a general parsing exception |
| */ |
| public static JPQLException generalParsingException(String theEjbql) { |
| Object[] args = { theEjbql }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, generalParsingException2, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(generalParsingException); |
| return exception; |
| } |
| |
| public static JPQLException classNotFoundException(String theClassName, String theMessage, Exception theException) { |
| Object[] args = { theClassName, theMessage }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, classNotFoundException, args); |
| JPQLException exception = new JPQLException(message, theException, classNotFoundException); |
| exception.setErrorCode(classNotFoundException); |
| return exception; |
| } |
| |
| public static JPQLException resolutionClassNotFoundException(String query, String theClassName) { |
| Object[] args = { query, theClassName }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, resolutionClassNotFoundException, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(resolutionClassNotFoundException); |
| return exception; |
| } |
| |
| public static JPQLException resolutionClassNotFoundException2(String query, int line, int column, String theClassName) { |
| Object[] args = { query, line, column, theClassName }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, resolutionClassNotFoundException2, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(resolutionClassNotFoundException2); |
| return exception; |
| } |
| |
| public static JPQLException missingDescriptorException(String query, String theClassName) { |
| Object[] args = { query, theClassName }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, missingDescriptorException, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(missingDescriptorException); |
| |
| return exception; |
| } |
| |
| public static JPQLException missingMappingException(String query, String theAttributeName) { |
| Object[] args = { query, theAttributeName }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, missingMappingException, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(missingMappingException); |
| |
| return exception; |
| } |
| |
| public static JPQLException aliasResolutionException(String query, int line, int column, String theAlias) { |
| Object[] args = { query, line, column, theAlias }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, aliasResolutionException, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(aliasResolutionException); |
| return exception; |
| } |
| |
| public static JPQLException invalidContextKeyException(String query, String theKey) { |
| Object[] args = { query, theKey }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, invalidContextKeyException, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidContextKeyException); |
| return exception; |
| } |
| |
| public static JPQLException expressionNotSupported(String query, String unsupportedExpression) { |
| Object[] args = { query, unsupportedExpression }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, expressionNotSupported, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(expressionNotSupported); |
| return exception; |
| } |
| |
| public static JPQLException invalidCollectionMemberDecl(String query, int line, int column, String attributeName) { |
| Object[] args = { query, line, column, attributeName }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidCollectionMemberDecl, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidCollectionMemberDecl); |
| return exception; |
| } |
| |
| public static JPQLException notYetImplemented(String query, String detail) { |
| Object[] args = { query, detail }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, notYetImplemented, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(notYetImplemented); |
| return exception; |
| } |
| |
| public static JPQLException constructorClassNotFound(String query, int line, int column, String className) { |
| Object[] args = { query, line, column, className }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, constructorClassNotFound, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(constructorClassNotFound); |
| return exception; |
| } |
| |
| public static JPQLException invalidSizeArgument(String query, int line, int column, String attributeName) { |
| Object[] args = { query, line, column, attributeName }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidSizeArgument, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidSizeArgument); |
| return exception; |
| } |
| |
| public static JPQLException invalidEnumLiteral(String query, int line, int column, String enumType, String literal) { |
| Object[] args = { query, line, column, enumType, literal }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidEnumLiteral, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidEnumLiteral); |
| return exception; |
| } |
| |
| public static JPQLException invalidSelectForGroupByQuery(String query, int line, int column, String select, String groupBy) { |
| Object[] args = { query, line, column, select, groupBy }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidSelectForGroupByQuery, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidSelectForGroupByQuery); |
| return exception; |
| } |
| |
| public static JPQLException invalidHavingExpression(String query, int line, int column, String having, String groupBy) { |
| Object[] args = { query, line, column, having, groupBy }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidHavingExpression, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidHavingExpression); |
| return exception; |
| } |
| |
| public static JPQLException invalidMultipleUseOfSameParameter( |
| String query, int line, int column, String parameter, String oldType, String newType) { |
| Object[] args = { query, line, column , parameter, oldType, newType }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidMultipleUseOfSameParameter, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidMultipleUseOfSameParameter); |
| return exception; |
| } |
| |
| public static JPQLException multipleVariableDeclaration( |
| String query, int line, int column, String variable, String oldDecl) { |
| Object[] args = { query, line, column, variable, oldDecl }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, multipleVariableDeclaration, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(multipleVariableDeclaration); |
| return exception; |
| } |
| |
| public static JPQLException invalidFunctionArgument(String query, int line, int column, String functionName, String attributeName, String type) { |
| Object[] args = { query, line, column, functionName, attributeName, type }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidFunctionArgument, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidFunctionArgument); |
| return exception; |
| } |
| |
| public static JPQLException invalidExpressionArgument(String query, int line, int column, String expression, String attributeName, String type) { |
| Object[] args = { query, line, column, expression, attributeName, type }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidExpressionArgument, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidExpressionArgument); |
| return exception; |
| } |
| |
| public static JPQLException unsupportJoinArgument(String query, int line, int column, String join, String type) { |
| Object[] args = { query, line, column, join, type }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, unsupportJoinArgument, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(unsupportJoinArgument); |
| return exception; |
| } |
| |
| public static JPQLException expectedOrderableOrderByItem(String query, int line, int column, String item, String type) { |
| Object[] args = { query, line, column, item, type }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, expectedOrderableOrderByItem, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(expectedOrderableOrderByItem); |
| return exception; |
| } |
| |
| public static JPQLException syntaxError(String query, Exception ex) { |
| Object[] args = { query }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, syntaxError, args); |
| JPQLException exception = new JPQLException(message, ex); |
| exception.setErrorCode(syntaxError); |
| return exception; |
| } |
| |
| public static JPQLException syntaxErrorAt(String query, int line, int column, String token, Exception ex) { |
| Object[] args = { query, line, column, token }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, syntaxErrorAt, args); |
| JPQLException exception = new JPQLException(message, ex); |
| exception.setErrorCode(syntaxErrorAt); |
| return exception; |
| } |
| |
| public static JPQLException unexpectedToken(String query, int line, int column, String token, Exception ex) { |
| Object[] args = { query, line, column, token }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, unexpectedToken, args); |
| JPQLException exception = new JPQLException(message, ex); |
| exception.setErrorCode(unexpectedToken); |
| return exception; |
| } |
| |
| public static JPQLException unexpectedChar(String query, int line, int column, String unexpected, Exception ex) { |
| Object[] args = { query, line, column, unexpected }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, unexpectedChar, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(unexpectedChar); |
| return exception; |
| } |
| |
| public static JPQLException expectedCharFound(String query, int line, int column, String expected, String found, Exception ex) { |
| Object[] args = { query, line, column, expected, found }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, expectedCharFound, args); |
| JPQLException exception = new JPQLException(message, ex); |
| exception.setErrorCode(expectedCharFound); |
| return exception; |
| } |
| |
| public static JPQLException unexpectedEOF(String query, int line, int column, Exception ex) { |
| Object[] args = { query, line, column}; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, unexpectedEOF, args); |
| JPQLException exception = new JPQLException(message, ex); |
| exception.setErrorCode(unexpectedEOF); |
| return exception; |
| } |
| |
| public static JPQLException invalidNavigation( |
| String query, int line, int column, String expr, String lhs, String type) { |
| Object[] args = { query, line, column, expr, lhs, type }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidNavigation, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidNavigation); |
| return exception; |
| } |
| |
| public static JPQLException invalidCollectionNavigation( |
| String query, int line, int column, String expr, String attribute) { |
| Object[] args = { query, line, column, expr, attribute }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidCollectionNavigation, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidCollectionNavigation); |
| return exception; |
| } |
| |
| public static JPQLException invalidSetClauseTarget( |
| String query, int line, int column, String expr, String attribute) { |
| Object[] args = { query, line, column, attribute, expr }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidSetClauseTarget, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidSetClauseTarget); |
| return exception; |
| } |
| |
| public static JPQLException invalidSetClauseNavigation( |
| String query, int line, int column, String expr, String relationship) { |
| Object[] args = { query, line, column, expr, relationship }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidSetClauseNavigation, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidSetClauseNavigation); |
| return exception; |
| } |
| |
| public static JPQLException unknownAttribute( |
| String query, int line, int column, String attribute, String type) { |
| Object[] args = { query, line, column, attribute, type }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, unknownAttribute, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(unknownAttribute); |
| return exception; |
| } |
| |
| public static JPQLException invalidEnumEqualExpression(String query, int line, int column, String enumType, String type) { |
| Object[] args = { query, line, column, enumType, type }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, invalidEnumEqualExpression, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(invalidEnumEqualExpression); |
| return exception; |
| } |
| |
| /** |
| * <b>{@link JPQLException} Entity Type Not Found</b> |
| * <p> |
| * Indicates that a type specified in a JPQL query string cannot be found in |
| * the current persistence unit. Ensure that the entity name is properly |
| * spelled and matches the name of an entity in the persistence unit being |
| * used. |
| */ |
| public static JPQLException entityTypeNotFound(String query, String type) { |
| Object[] args = { query, type }; |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, entityTypeNotFound, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(entityTypeNotFound); |
| return exception; |
| } |
| |
| public static JPQLException entityTypeNotFound2(String query, int line, int column, String type) { |
| Object[] args = { query, line, column, type }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, entityTypeNotFound2, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(entityTypeNotFound2); |
| return exception; |
| } |
| |
| public static JPQLException variableCannotHaveMapKey(String query, int line, int column, String name) { |
| Object[] args = { query, line, column, name }; |
| |
| String message = ExceptionMessageGenerator.buildMessage(JPQLException.class, variableCannotHaveMapKey, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(variableCannotHaveMapKey); |
| return exception; |
| } |
| |
| public static JPQLException nonExistantOrderByAlias(String query, int line, int column, String alias) { |
| Object[] args = { query, line, column, alias }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, nonExistantOrderByAlias, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(nonExistantOrderByAlias); |
| return exception; |
| } |
| |
| public static JPQLException indexOnlyAllowedOnVariable(String query, int line, int column, String node) { |
| Object[] args = { query, line, column, node }; |
| |
| String message = ExceptionMessageGenerator.buildMessage( |
| JPQLException.class, indexOnlyAllowedOnVariable, args); |
| JPQLException exception = new JPQLException(message); |
| exception.setErrorCode(indexOnlyAllowedOnVariable); |
| return exception; |
| } |
| |
| /** |
| * INTERNAL |
| * Add an internal Exception to the collection of |
| * internal Exceptions |
| */ |
| public Object addInternalException(Object theException) { |
| getInternalExceptions().add(theException); |
| return theException; |
| } |
| |
| /** |
| * INTERNAL |
| * Does this exception have any internal errors? |
| */ |
| public boolean hasInternalExceptions() { |
| return !getInternalExceptions().isEmpty(); |
| } |
| |
| /** |
| * INTERNAL |
| * Return the collection of internal Exceptions. |
| * Intialize if there are no exceptions |
| */ |
| public Collection getInternalExceptions() { |
| if (internalExceptions == null) { |
| setInternalExceptions(new Vector()); |
| } |
| return internalExceptions; |
| } |
| |
| /** |
| * INTERNAL |
| * Store the exceptions related to this exception |
| */ |
| public void setInternalExceptions(Collection theExceptions) { |
| internalExceptions = theExceptions; |
| } |
| |
| /** |
| * PUBLIC |
| * Print the stack trace for each error generated by the |
| * parser. This method is intended to assist in debugging |
| * problems in EJBQL |
| */ |
| public void printFullStackTrace() { |
| if (hasInternalExceptions()) { |
| Iterator exceptions = getInternalExceptions().iterator(); |
| while (exceptions.hasNext()) { |
| Throwable error = (Throwable)exceptions.next(); |
| error.printStackTrace(); |
| } |
| } |
| } |
| } |
