JPQL: Receiving a Collection in a Constructor Expression

by

The JPA spec (Version 2.0, 2.1 and 2.2 at least) doesn’t allow the use of collections as parameters in constructor expressions. Section 4.8 defines a constructor expression like this:

constructor_expression ::=
        NEW constructor_name ( constructor_item {, constructor_item}* )
constructor_item ::=
        single_valued_path_expression |
        scalar_expression |
        aggregate_expression |
        identification_variable

A single_valued_path_expression is what it sounds like – a property expression that points to a scalar of some sort (such as p.id), a scalar_expression is also an expression that points to scalar, an aggregate_expression is the application of a function like sum which reduces a multi-valued expression to a scalar one, and an identification_variable is a reference to the type you’re querying over. None of which can be collection-valued.

So, if your JPA provider lets you use collection-valued parameter in a constructor expression, it’s because it’s going above and beyond the spec. Which is very nice of it, but not something you can necessarily rely on!

More Related Contents:

  1. JPQL Create new Object In Select Statement – avoid or embrace?
  2. Adding IN clause List to a JPA Query
  3. Parameter in like clause JPQL
  4. How to use multiple JOIN FETCH in one JPQL query
  5. Limit number of results in JPQL
  6. How To Define a JPA Repository Query with a Join
  7. Using the JPA Criteria API, can you do a fetch join that results in only one join?
  8. Doing an “IN” query with Hibernate
  9. Setting a parameter as a list for an IN expression
  10. How can I avoid the Warning “firstResult/maxResults specified with collection fetch; applying in memory!” when using Hibernate?
  11. IN-clause in HQL or Java Persistence Query Language
  12. JPA Native Query select and cast object
  13. Spring Data JPA and Exists query
  14. JPQL Like Case Insensitive
  15. JPA: JOIN in JPQL
  16. How to create a JPA query with LEFT OUTER JOIN
  17. What’s the difference between the IN and MEMBER OF JPQL operators?
  18. JPA Select latest instance for each item
  19. Difference between FetchType LAZY and EAGER in Java Persistence API?
  20. Why is Hibernate Open Session in View considered a bad practice?
  21. JPA: How to have one-to-many relation of the same Entity type
  22. Can I call methods in constructor in Java?
  23. Unique constraint with JPA and Bean Validation
  24. How to prevent SQL Injection with JPA and Hibernate?
  25. JPA, How to use the same class (entity) to map different tables?
  26. @Id @GeneratedValue but set own ID value
  27. Is it possible to write a generic enum converter for JPA?
  28. Difference between @MapKey, @MapKeyColumn and @MapKeyJoinColumn in JPA and Hibernate
  29. Name attribute in @Entity and @Table
  30. TransactionRequiredException Executing an update/delete query

Leave a Comment