private void validateParameterBinding(Parameter parameter, Object value) { if (value == null || parameter.getParameterType() == null) { // nothing we can check return; } if (Collection.class.isInstance(value) && !Collection.class.isAssignableFrom(parameter.getParameterType())) { // we have a collection passed in where we are expecting a non-collection. // NOTE : this can happen in Hibernate's notion of "parameter list" binding // NOTE2 : the case of a collection value and an expected collection (if that can even // happen) // will fall through to the main check. validateCollectionValuedParameterMultiBinding(parameter, (Collection) value); } else if (value.getClass().isArray()) { validateArrayValuedParameterBinding(parameter, value); } else { if (!parameter.getParameterType().isInstance(value)) { throw new IllegalArgumentException( String.format( "Parameter value [%s] did not match expected type [%s]", value, parameter.getParameterType().getName())); } } }
/** * Returns whether the given {@link Query} contains named parameters. * * @param query * @return */ public static boolean hasNamedParameter(Query query) { for (Parameter<?> parameter : query.getParameters()) { if (parameter.getName() != null) { return true; } } return false; }
/** {@inheritDoc} */ public Parameter<?> getParameter(String name) { if (name == null) { throw new IllegalArgumentException("Name of parameter to locate cannot be null"); } for (Parameter parameter : parameters) { if (name.equals(parameter.getName())) { return parameter; } } throw new IllegalArgumentException("Unable to locate parameter named [" + name + "]"); }
private void validateCollectionValuedParameterMultiBinding( Parameter parameter, Collection value) { // validate the elements... for (Object element : value) { if (!parameter.getParameterType().isInstance(element)) { throw new IllegalArgumentException( String.format( "Parameter value element [%s] did not match expected type [%s]", element, parameter.getParameterType().getName())); } } }
public TypedQuery<X> setParameter(Parameter<Date> param, Date value, TemporalType temporalType) { if (!parameters.contains(param)) { throw new IllegalArgumentException("Specified parameter was not found in query"); } if (param.getName() != null) { // a named param, for not delegate out. Eventually delegate *into* this method... setParameter(param.getName(), value, temporalType); } else { setParameter(param.getPosition(), value, temporalType); } return this; }
/** {@inheritDoc} */ public Parameter<?> getParameter(int position) { if (isJpaPositionalParameter(position)) { return getParameter(Integer.toString(position)); } else { for (Parameter parameter : parameters) { if (parameter.getPosition() != null && position == parameter.getPosition()) { return parameter; } } throw new IllegalArgumentException( "Unable to locate parameter with position [" + position + "]"); } }
/** * Returns whether the given {@link Query} contains named parameters. * * @param query * @return */ public static boolean hasNamedParameter(Query query) { for (Parameter<?> parameter : query.getParameters()) { String name = parameter.getName(); // Hibernate 3 specific hack as it returns the index as String for the name. if (name != null && NO_DIGITS.matcher(name).find()) { return true; } } return false; }
/** {@inheritDoc} */ @SuppressWarnings({"unchecked"}) public <T> Parameter<T> getParameter(int position, Class<T> type) { Parameter param = getParameter(position); if (param.getParameterType() != null) { // we were able to determine the expected type during analysis, so validate it here throw new IllegalArgumentException( "Parameter type [" + param.getParameterType().getName() + "] is not assignment compatible with requested type [" + type.getName() + "]"); } return param; }
private void setQueryParameters(Query query, SearchParameters sp) { // add default parameter if specified in the named query for (Parameter<?> p : query.getParameters()) { if (NAMED_PARAMETER_CURRENT_USER_ID.equals(p.getName())) { query.setParameter(NAMED_PARAMETER_CURRENT_USER_ID, UserContext.getId()); } else if (NAMED_PARAMETER_NOW.equals(p.getName())) { query.setParameter(NAMED_PARAMETER_NOW, Calendar.getInstance().getTime()); } } // add parameters for the named query for (String paramName : sp.getNamedQueryParameters().keySet()) { query.setParameter(paramName, sp.getNamedQueryParameter(paramName)); } }
@Override @SuppressWarnings("unchecked") public <T> Parameter<T> getParameter(String name, Class<T> type) { checkOpen(false); Parameter param = getParameter(name); if (param.getParameterType() != null) { // we were able to determine the expected type during analysis, so validate it here if (!param.getParameterType().isAssignableFrom(type)) { throw new IllegalArgumentException( String.format( "Parameter type [%s] is not assignment compatible with requested type [%s] for parameter named [%s]", param.getParameterType().getName(), type.getName(), name)); } } return (Parameter<T>) param; }
protected <X> ParameterRegistration<X> findParameterRegistration(Parameter<X> parameter) { if (ParameterRegistration.class.isInstance(parameter)) { final ParameterRegistration<X> reg = (ParameterRegistration<X>) parameter; // validate the parameter source if (reg.getQuery() != this) { throw new IllegalArgumentException("Passed Parameter was from different Query"); } return reg; } else { if (parameter.getName() != null) { return findParameterRegistration(parameter.getName()); } else if (parameter.getPosition() != null) { return findParameterRegistration(parameter.getPosition()); } } throw new IllegalArgumentException( "Unable to resolve incoming parameter [" + parameter + "] to registration"); }
@Test public void testNamedParameterMetadata() { EntityManager em = getOrCreateEntityManager(); em.getTransaction().begin(); CriteriaQuery<MultiTypedBasicAttributesEntity> criteria = em.getCriteriaBuilder().createQuery(MultiTypedBasicAttributesEntity.class); Root<MultiTypedBasicAttributesEntity> rootEntity = criteria.from(MultiTypedBasicAttributesEntity.class); criteria.where( em.getCriteriaBuilder() .equal( rootEntity.get(MultiTypedBasicAttributesEntity_.id), em.getCriteriaBuilder().parameter(Long.class, "id"))); TypedQuery<MultiTypedBasicAttributesEntity> query = em.createQuery(criteria); Parameter parameter = query.getParameter("id"); assertEquals("id", parameter.getName()); em.getTransaction().commit(); em.close(); }
private void validateArrayValuedParameterBinding(Parameter parameter, Object value) { if (!parameter.getParameterType().isArray()) { throw new IllegalArgumentException( String.format( "Encountered array-valued parameter binding, but was expecting [%s]", parameter.getParameterType().getName())); } if (value.getClass().getComponentType().isPrimitive()) { // we have a primitive array. we validate that the actual array has the component type (type // odf elements) // we expect based on the component type of the parameter specification if (!parameter .getParameterType() .getComponentType() .isAssignableFrom(value.getClass().getComponentType())) { throw new IllegalArgumentException( String.format( "Primitive array-valued parameter bind value type [%s] did not match expected type [%s]", value.getClass().getComponentType().getName(), parameter.getParameterType().getName())); } } else { // we have an object array. Here we loop over the array and physically check each element // against // the type we expect based on the component type of the parameter specification final Object[] array = (Object[]) value; for (Object element : array) { if (!parameter.getParameterType().getComponentType().isInstance(element)) { throw new IllegalArgumentException( String.format( "Array-valued parameter value element [%s] did not match expected type [%s]", element, parameter.getParameterType().getName())); } } } }