/** * PUBLIC: * Add the argument named argumentName and its class type. * This will cause the translation of references of argumentName in the receiver's expression, * with the value of the argument as supplied to the query in order from executeQuery(). * Specifying the class type is important if identically named queries are used but with * different argument lists. */ public void addArgument(String argumentName, Class type) { getArguments().add(argumentName); getArgumentTypes().add(type); getArgumentTypeNames().add(type.getName()); }
/** * INTERNAL: Build the list of arguments fields from the argument names and types. */ public List<DatabaseField> buildArgumentFields() { List arguments = getArguments(); List argumentTypes = getArgumentTypes(); List argumentFields = new ArrayList(arguments.size()); int size = arguments.size(); for (int index = 0; index < size; index++) { DatabaseField argumentField = new DatabaseField((String)arguments.get(index)); argumentField.setType((Class)argumentTypes.get(index)); argumentFields.add(argumentField); } return argumentFields; }
/** * PUBLIC: * Remove the specific query with the given queryName and argumentTypes. */ public void removeQuery(String queryName, Vector argumentTypes) { Vector queries = (Vector)getQueries().get(queryName); if (queries == null) { return; } else { DatabaseQuery query = null; for (Enumeration enumtr = queries.elements(); enumtr.hasMoreElements();) { query = (DatabaseQuery)enumtr.nextElement(); if (Helper.areTypesAssignable(argumentTypes, query.getArgumentTypes())) { break; } } if (query != null) { queries.remove(query); } } }
/** * PUBLIC: * Remove the specific query with the given queryName and argumentTypes. * * @see #removeQuery(String) */ public void removeQuery(String queryName, Vector argumentTypes) { Vector queries = (Vector)getQueries().get(queryName); if (queries == null) { return; } else { DatabaseQuery query = null; for (Enumeration enumtr = queries.elements(); enumtr.hasMoreElements();) { query = (DatabaseQuery)enumtr.nextElement(); if (Helper.areTypesAssignable(argumentTypes, query.getArgumentTypes())) { break; } } if (query != null) { queries.remove(query); } } }
/** * INTERNAL: Build the list of arguments fields from the argument names and * types. */ public List<DatabaseField> buildArgumentFields() { List arguments = getArguments(); List argumentTypes = getArgumentTypes(); List argumentFields = new ArrayList(arguments.size()); int size = arguments.size(); for (int index = 0; index < size; index++) { DatabaseField argumentField = new DatabaseField((String) arguments.get(index)); argumentField.setType((Class) argumentTypes.get(index)); argumentFields.add(argumentField); } return argumentFields; }
/** * INTERNAL: Build the list of arguments fields from the argument names and * types. */ public List<DatabaseField> buildArgumentFields() { List arguments = getArguments(); List argumentTypes = getArgumentTypes(); List argumentFields = new ArrayList(arguments.size()); int size = arguments.size(); for (int index = 0; index < size; index++) { DatabaseField argumentField = new DatabaseField((String) arguments.get(index)); argumentField.setType((Class) argumentTypes.get(index)); argumentFields.add(argumentField); } return argumentFields; }
/** * PUBLIC: * Remove the specific query with the given queryName and argumentTypes. */ public void removeQuery(String queryName, Vector argumentTypes) { Vector queries = (Vector)getQueries().get(queryName); if (queries == null) { return; } else { DatabaseQuery query = null; for (Enumeration enumtr = queries.elements(); enumtr.hasMoreElements();) { query = (DatabaseQuery)enumtr.nextElement(); if (Helper.areTypesAssignable(argumentTypes, query.getArgumentTypes())) { break; } } if (query != null) { queries.remove(query); } } }
/** * PUBLIC: * Remove the specific query with the given queryName and argumentTypes. */ public void removeQuery(String queryName, Vector argumentTypes) { Vector queries = (Vector)getQueries().get(queryName); if (queries == null) { return; } else { DatabaseQuery query = null; for (Enumeration enumtr = queries.elements(); enumtr.hasMoreElements();) { query = (DatabaseQuery)enumtr.nextElement(); if (Helper.areTypesAssignable(argumentTypes, query.getArgumentTypes())) { break; } } if (query != null) { queries.remove(query); } } }
/** * INTERNAL: Add the argument named argumentName. This method was added to maintain * information about whether parameters are positional or named for JPQL query introspeciton * API */ public void addArgument(String argumentName, Class type, ParameterType argumentParameterType, boolean nullable) { getArguments().add(argumentName); getArgumentTypes().add(type); getArgumentParameterTypes().add(argumentParameterType); getArgumentTypeNames().add(type.getName()); if (nullable) { getNullableArguments().add(new DatabaseField(argumentName)); } }
/** * PUBLIC: Add the argument named argumentName and its class type. This will * cause the translation of references of argumentName in the receiver's * expression, with the value of the argument as supplied to the query in * order from executeQuery(). Specifying the class type is important if * identically named queries are used but with different argument lists. * If the argument can be null, and null must be treated differently in the * generated SQL, then nullable should be set to true. */ public void addArgument(String argumentName, Class type, boolean nullable) { getArguments().add(argumentName); getArgumentTypes().add(type); getArgumentTypeNames().add(type.getName()); if (nullable) { getNullableArguments().add(new DatabaseField(argumentName)); } }
/** * INTERNAL: Add the argument named argumentName. This method was added to maintain * information about whether parameters are positional or named for JPQL query introspeciton * API */ public void addArgument(String argumentName, Class type, ParameterType argumentParameterType, boolean nullable) { getArguments().add(argumentName); getArgumentTypes().add(type); getArgumentParameterTypes().add(argumentParameterType); getArgumentTypeNames().add(type.getName()); if (nullable) { getNullableArguments().add(new DatabaseField(argumentName)); } }
public static ValidationException existingQueryTypeConflict(DatabaseQuery newQuery, DatabaseQuery existingQuery) { Object[] args = { newQuery, newQuery.getName(), newQuery.getArgumentTypes(), existingQuery, existingQuery.getName(), existingQuery.getArgumentTypes() }; ValidationException validationException = new ValidationException(ExceptionMessageGenerator.buildMessage(ValidationException.class, EXISTING_QUERY_TYPE_CONFLICT, args)); validationException.setErrorCode(EXISTING_QUERY_TYPE_CONFLICT); return validationException; }
/** * PUBLIC: * Add the argument named argumentName and its class type. * This will cause the translation of references of argumentName in the receiver's expression, * with the value of the argument as supplied to the query in order from executeQuery(). * Specifying the class type is important if identically named queries are used but with * different argument lists. */ public void addArgument(String argumentName, String typeAsString) { getArguments().add(argumentName); //bug 3197587 getArgumentTypes().add(Helper.getObjectClass(ConversionManager.loadClass(typeAsString))); getArgumentTypeNames().add(typeAsString); }
/** * PUBLIC: Add the argument named argumentName and its class type. This will * cause the translation of references of argumentName in the receiver's * expression, with the value of the argument as supplied to the query in * order from executeQuery(). Specifying the class type is important if * identically named queries are used but with different argument lists. */ public void addArgument(String argumentName, String typeAsString) { getArguments().add(argumentName); // bug 3197587 getArgumentTypes().add(Helper.getObjectClass(ConversionManager.loadClass(typeAsString))); getArgumentTypeNames().add(typeAsString); }
public static ValidationException existingQueryTypeConflict(DatabaseQuery newQuery, DatabaseQuery existingQuery) { Object[] args = { newQuery, newQuery.getName(), newQuery.getArgumentTypes(), existingQuery, existingQuery.getName(), existingQuery.getArgumentTypes() }; ValidationException validationException = new ValidationException(ExceptionMessageGenerator.buildMessage(ValidationException.class, EXISTING_QUERY_TYPE_CONFLICT, args)); validationException.setErrorCode(EXISTING_QUERY_TYPE_CONFLICT); return validationException; }
/** * PUBLIC: Add the argument named argumentName and its class type. This will * cause the translation of references of argumentName in the receiver's * expression, with the value of the argument as supplied to the query in * order from executeQuery(). Specifying the class type is important if * identically named queries are used but with different argument lists. * If the argument can be null, and null must be treated differently in the * generated SQL, then nullable should be set to true. */ public void addArgument(String argumentName, Class type, boolean nullable) { getArguments().add(argumentName); getArgumentTypes().add(type); getArgumentTypeNames().add(type.getName()); if (nullable) { getNullableArguments().add(new DatabaseField(argumentName)); } }
/** * PUBLIC: Add the argument named argumentName and its class type. This will * cause the translation of references of argumentName in the receiver's * expression, with the value of the argument as supplied to the query in * order from executeQuery(). Specifying the class type is important if * identically named queries are used but with different argument lists. */ public void addArgument(String argumentName, String typeAsString) { getArguments().add(argumentName); // bug 3197587 getArgumentTypes().add(Helper.getObjectClass(ConversionManager.loadClass(typeAsString))); getArgumentTypeNames().add(typeAsString); }
public static ValidationException existingQueryTypeConflict(DatabaseQuery newQuery, DatabaseQuery existingQuery) { Object[] args = { newQuery, newQuery.getName(), newQuery.getArgumentTypes(), existingQuery, existingQuery.getName(), existingQuery.getArgumentTypes() }; ValidationException validationException = new ValidationException(ExceptionMessageGenerator.buildMessage(ValidationException.class, EXISTING_QUERY_TYPE_CONFLICT, args)); validationException.setErrorCode(EXISTING_QUERY_TYPE_CONFLICT); return validationException; }
/** * INTERNAL: * Add the query to the session queries. */ protected void addQuery(DatabaseQuery query) { Vector queriesByName = (Vector)getQueries().get(query.getName()); if (queriesByName == null) { // lazily create Vector in Hashtable. queriesByName = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(); getQueries().put(query.getName(), queriesByName); } // Check that we do not already have a query that matched it for (Enumeration enumtr = queriesByName.elements(); enumtr.hasMoreElements();) { DatabaseQuery existingQuery = (DatabaseQuery)enumtr.nextElement(); if (Helper.areTypesAssignable(query.getArgumentTypes(), existingQuery.getArgumentTypes())) { throw ValidationException.existingQueryTypeConflict(query, existingQuery); } } queriesByName.add(query); }
/** * INTERNAL: * Add the query to the session queries. */ protected synchronized void addQuery(DatabaseQuery query, boolean nameMustBeUnique) { Vector queriesByName = (Vector)getQueries().get(query.getName()); if (queriesByName == null) { // lazily create Vector in Hashtable. queriesByName = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(); getQueries().put(query.getName(), queriesByName); } if (nameMustBeUnique){ // JPA addNamedQuery if (queriesByName.size() <= 1){ queriesByName.clear(); }else{ throw new IllegalStateException(ExceptionLocalization.buildMessage("argument_keyed_named_query_with_JPA", new Object[]{query.getName()})); } }else{ // Check that we do not already have a query that matched it for (Iterator enumtr = queriesByName.iterator(); enumtr.hasNext();) { DatabaseQuery existingQuery = (DatabaseQuery)enumtr.next(); if (Helper.areTypesAssignable(query.getArgumentTypes(), existingQuery.getArgumentTypes())) { throw ValidationException.existingQueryTypeConflict(query, existingQuery); } } } queriesByName.add(query); }