Chapter 10. JPA Query

+The javax.persistence.Query interface is the mechanism +for issuing queries in JPA. The primary query language used is the Java +Persistence Query Language, or JPQL. JPQL is syntactically +very similar to SQL, but is object-oriented rather than table-oriented. +

+The API for executing JPQL queries will be discussed in +Section 1, “ + JPQL API + ”, and a full language reference will be +covered in Section 2, “ + JPQL Language Reference + ”. +

1. + JPQL API +

1.1. + Query Basics +

1.2. + Relation Traversal +

1.3. + Embeddable Traversal +

1.4. + Fetch Joins +

1.5. + JPQL Functions +

1.6. + Polymorphic Queries +

1.7. + Query Parameters +

1.8. + Query Hints +

1.8.1. + Locking Hints +
1.8.2. + Lock Timeout Hint +
1.8.3. + Query Timeout Hint +
1.8.4. + Result Set Size Hint +
1.8.5. + Isolation Level Hint +
1.8.6. + Other Fetchplan Hints +
1.8.7. + Database-Specific Hints +
1.8.8. + Named Query Hints +
1.8.9. + Handling of Multiple Similar Query Hints +

1.9. + Ordering +

1.10. + Aggregates +

1.11. + Named Queries +

1.12. + Delete By Query +

1.13. + Update By Query +

+ +

1.1. + Query Basics +

+ +

SELECT x FROM Magazine x
+

+The preceding is a simple JPQL query for all Magazine +entities. +

+public Query createQuery(String jpql);
+

+The + +EntityManager.createQuery method creates a +Query instance from a given JPQL string. +

+public List getResultList();
+

+Invoking + +Query.getResultList executes the query and +returns a List containing the matching objects. The +following example executes our Magazine query above: +

+EntityManager em = ...
+Query q = em.createQuery("SELECT x FROM Magazine x");
+List<Magazine> results = (List<Magazine>) q.getResultList();
+

+A JPQL query has an internal namespace declared in the from +clause of the query. Arbitrary identifiers are assigned to entities so that they +can be referenced elsewhere in the query. In the query example above, the +identifier x is assigned to the entity Magazine +. +

Note

+The as keyword can optionally be used when declaring +identifiers in the from clause. SELECT x FROM +Magazine x and SELECT x FROM Magazine AS x are +synonymous. +

+Following the select clause of the query is the object or +objects that the query returns. In the case of the query above, the query's +result list will contain instances of the Magazine class. +

Note

+When selecting entities, you can optionally use the keyword object +. The clauses select x and SELECT +OBJECT(x) are synonymous. +

+The optional where clause places criteria on matching +results. For example: +

SELECT x FROM Magazine x WHERE x.title = 'JDJ'

+Keywords in JPQL expressions are case-insensitive, but entity, identifier, and +member names are not. For example, the expression above could also be expressed +as: +

select x from Magazine x where x.title = 'JDJ'

+But it could not be expressed as: +

SELECT x FROM Magazine x WHERE x.TITLE = 'JDJ'

+As with the select clause, alias names in the where + clause are resolved to the entity declared in the from + clause. The query above could be described in English as "for all +Magazine instances x, return a list +of every x such that x's title + field is equal to 'JDJ'". +

+JPQL uses SQL-like syntax for query criteria. The and and +or logical operators chain multiple criteria together: +

+SELECT x FROM Magazine x WHERE x.title = 'JDJ' OR x.title = 'JavaPro'
+

+The = operator tests for equality. <> + tests for inequality. JPQL also supports the following arithmetic +operators for numeric comparisons: >, >=, <, <=. +For example: +

+SELECT x FROM Magazine x WHERE x.price > 3.00 AND x.price <= 5.00
+

+This query returns all magazines whose price is greater than 3.00 and less than +or equal to 5.00. +

+SELECT x FROM Magazine x WHERE x.price <> 3.00
+

+This query returns all Magazines whose price is not equal to 3.00. +

+You can group expressions together using parentheses in order to specify how +they are evaluated. This is similar to how parentheses are used in Java. For +example: +

+SELECT x FROM Magazine x WHERE (x.price > 3.00 AND x.price <= 5.00) OR x.price < 7.00
+

+This expression would match magazines whose price is less than 7.00. +Alternately: +

+SELECT x FROM Magazine x WHERE x.price > 3.00 AND (x.price <= 5.00 OR x.price < 7.00)
+

+This expression would match magazines whose price is 4.00, 5.00 or 6.00, but not +1.00, 2.00 or 3.00. +

+JPQL also includes the following conditionals: +

+
+ +[NOT] BETWEEN: Shorthand for expressing that a value falls +between two other values. The following two statements are synonymous: +
+
```
+SELECT x FROM Magazine x WHERE x.price >= 3.00 AND x.price <= 5.00
+
```
+
```
+SELECT x FROM Magazine x WHERE x.price BETWEEN 3.00 AND 5.00
+
```
+
+
+ +[NOT] LIKE: Performs a string comparison with wildcard +support. The special character '_' in the parameter means to match any single +character, and the special character '%' means to match any sequence of +characters. The following statement matches title fields "JDJ" and "JavaPro", +but not "IT Insider": +
+
```
+SELECT x FROM Magazine x WHERE x.title LIKE 'J%'
+
```
+
+The following statement matches the title field "JDJ" but not "JavaPro": +
+
```
+SELECT x FROM Magazine x WHERE x.title LIKE 'J__'
+
```
+

+ +[NOT] IN: Specifies that the member must be equal to one +element of the provided list. The following two statements are synonymous: +

+SELECT x FROM Magazine x WHERE x.title IN ('JDJ', 'JavaPro', 'IT Insider')
+

SELECT x FROM Magazine x WHERE x.title = 'JDJ' OR x.title = 'JavaPro' OR x.title = 'IT Insider'
+

+
+ +IS [NOT] EMPTY: Specifies that the collection field holds no +elements. For example: +
+
```
+SELECT x FROM Magazine x WHERE x.articles is empty
+
```
+
+This statement will return all magazines whose articles +member contains no elements. +
+
+
+ +IS [NOT] NULL: Specifies that the field is equal to null. +For example: +
+
```
+SELECT x FROM Magazine x WHERE x.publisher is null
+
```
+
+This statement will return all Magazine instances whose "publisher" field is set +to null. +
+
+
+ +NOT: Negates the contained expression. For example, the +following two statements are synonymous: +
+
```
+SELECT x FROM Magazine x WHERE NOT(x.price = 10.0)
+
```
+
```
+SELECT x FROM Magazine x WHERE x.price <> 10.0
+
```
+

1.2. + Relation Traversal +

+ +

+Relations between objects can be traversed using Java-like syntax. For example, +if the Magazine class has a field named "publisher" of type Company, that +relation can be queried as follows: +

+SELECT x FROM Magazine x WHERE x.publisher.name = 'Random House'
+

+This query returns all Magazine instances whose +publisher field is set to a Company instance +whose name is "Random House". +

+Single-valued relation traversal implies that the relation is not null. In SQL +terms, this is known as an inner join. If you want to also +include relations that are null, you can specify: +

+SELECT x FROM Magazine x WHERE x.publisher.name = 'Random House' or x.publisher is null
+

+You can also traverse collection fields in queries, but you must declare each +traversal in the from clause. Consider: +

+SELECT x FROM Magazine x, IN(x.articles) y WHERE y.authorName = 'John Doe'
+

+This query says that for each Magazinex +, traverse the articles relation and check each +Article y, and pass the filter if +y's authorName field is equal to "John +Doe". In short, this query will return all magazines that have any articles +written by John Doe. +

Note

+The IN() syntax can also be expressed with the keywords +inner join. The statements SELECT x FROM Magazine +x, IN(x.articles) y WHERE y.authorName = 'John Doe' and +SELECT x FROM Magazine x inner join x.articles y WHERE y.authorName = 'John Doe' + are synonymous. +

1.3. + Embeddable Traversal +

+ +

+Similar to relation traversal, nested embeddable objects can be traversed using Java-like syntax. +For example, if the Company class has a field named "address" of +an embeddable type Address, +and the Address has a field named "geocode" of +an embeddable type Geocode, +the geocode of a company's address can be queried as follows: +

+SELECT c.address.geocode FROM Company c WHERE c.name = 'Random House'
+

Note

+The geocode returned by the above query will not be part of the state of any managed +entity. Modifications to these embeddable instances are not allowed. +

+Traversal into embeddable's state field is also allowed as shown in the following query: +

+SELECT c.address.geocode.latitude FROM Company c WHERE c.name = 'Random House'
+

+Embeddable objects may contain single-valued or collection-valued relations. +These relations can also be traversed using Java-like syntax. +For example, if the Address has a relation field named "phoneLists" of +an entity type PhoneNumber, +the following query returns the PhoneNumber entities of the Company + named 'Random House': +

+SELECT p FROM Company c, IN(c.address.phoneLists) p WHERE c.name = 'Random House'
+

1.4. + Fetch Joins +

+ +

+JPQL queries may specify one or more join fetch declarations, +which allow the query to specify which fields in the returned instances will be +pre-fetched. +

+SELECT x FROM Magazine x join fetch x.articles WHERE x.title = 'JDJ'
+

+The query above returns Magazine instances and guarantees +that the articles field will already be fetched in the +returned instances. +

+Multiple fields may be specified in separate join fetch +declarations:

+SELECT x FROM Magazine x join fetch x.articles join fetch x.authors WHERE x.title = 'JDJ'
+

+Notice that in the above query, both articles and authors +are relation property in Magazine. +JPQL syntax does not allow range variable declared for paths on the right-hand side of +join fetch. +Therefore, if Article entity has a relation property of +publishers, +it is not possible to specify a query +that returns Magazine instances and pre-fetch +the articles and the publishers. +The following query will result in syntax error: +

+SELECT x FROM Magazine x join fetch x.articles a join fetch a.publishers p WHERE x.title = 'JDJ'
+

Note

Specifying the join fetch declaration is +functionally equivalent to adding the fields to the Query's +FetchConfiguration. See Section 7, “ + Fetch Groups + ”. +

1.5. + JPQL Functions +

+ +

+As well as supporting direct field and relation comparisons, JPQL supports a +pre-defined set of functions that you can apply. +

+
+ +CONCAT(string1, string2): Concatenates two string fields or +literals. For example: +
+
```
+SELECT x FROM Magazine x WHERE CONCAT(x.title, 's') = 'JDJs'
+
```
+
+
+ +SUBSTRING(string, startIndex, [length]): Returns the part of +the string argument starting at startIndex +(1-based) and optionally ending at length characters past +startIndex. If the length argument is not specified, +the substring from the startIndex to the end of the string +is returned. +
+
```
+SELECT x FROM Magazine x WHERE SUBSTRING(x.title, 1, 1) = 'J'
+
```
+
+
+ +TRIM([LEADING | TRAILING | BOTH] [character FROM] string: +Trims the specified character from either the beginning ( LEADING +) end ( TRAILING) or both ( BOTH +) of the string argument. If no trim character is specified, the +space character will be trimmed. +
+
```
+SELECT x FROM Magazine x WHERE TRIM(BOTH 'J' FROM x.title) = 'D'
+
```
+
+
+ +LOWER(string): Returns the lower-case of the specified +string argument. +
+
```
+SELECT x FROM Magazine x WHERE LOWER(x.title) = 'jdj'
+
```
+
+
+ +UPPER(string): Returns the upper-case of the specified +string argument. +
+
```
+SELECT x FROM Magazine x WHERE UPPER(x.title) = 'JAVAPRO'
+
```
+
+
+ +LENGTH(string): Returns the number of characters in the +specified string argument. +
+
```
+SELECT x FROM Magazine x WHERE LENGTH(x.title) = 3
+
```
+
+
+ +LOCATE(searchString, candidateString [, startIndex]): +Returns the first index of searchString in +candidateString. Positions are 1-based. If the string is not found, +returns 0. +
+
```
+SELECT x FROM Magazine x WHERE LOCATE('D', x.title) = 2
+
```
+
+
+ +ABS(number): Returns the absolute value of the argument. +
+
```
+SELECT x FROM Magazine x WHERE ABS(x.price) >= 5.00
+
```
+
+
+ +SQRT(number): Returns the square root of the argument. +
+
```
+SELECT x FROM Magazine x WHERE SQRT(x.price) >= 1.00
+
```
+
+
+ +MOD(number, divisor): Returns the modulo of number + and divisor. +
+
```
+SELECT x FROM Magazine x WHERE MOD(x.price, 10) = 0
+
```
+
+
+ +INDEX(identification_variable): Returns an integer value corresponding + to the position of its argument in an ordered list. + The INDEX function can only be applied to identification variables denoting types for +which an order column has been specified. +
+
+In the following example, studentWaitlist is a list of +students for which an order column has +been specified, the query returns the name of the first student on the waiting list of +the course named 'Calculus': +
+
```
+SELECT w.name FROM Course c JOIN c.studentWaitlist w WHERE c.name = ‘Calculus’ AND INDEX(w) = 0
+
```
+
+
+ +CURRENT_DATE: Returns the current date. +
+
+
+ +CURRENT_TIME: Returns the current time. +
+
+
+ +CURRENT_TIMESTAMP: Returns the current timestamp. +
+

1.6. + Polymorphic Queries +

+ +

+All JPQL queries are polymorphic, which means the from clause +of a query includes not only instances of the specific entity class to which it +refers, but all subclasses of that class as well. The instances returned by a +query include instances of the subclasses that satisfy the query conditions. For +example, the following query may return instances of Magazine +, as well as Tabloid and Digest + instances, where Tabloid and +Digest are Magazine subclasses. +

SELECT x FROM Magazine x WHERE x.price < 5

+Non-polymorphic queries or queries whose polymorphism is restricted can be specified using entity +type expressions (see Section 2.6.4, “ + Entity Type Expressions + ” ) + in the WHERE clause to restrict the domain of the query. +For example, the following query returns instances of Digest: +

+SELECT x FROM Magazine WHERE TYPE(x) = Digest
+

1.7. + Query Parameters +

+ +

+JPQL provides support for parameterized queries. Either named parameters or +positional parameters may be specified in the query string. Parameters allow you +to re-use query templates where only the input parameters vary. A single query +can declare either named parameters or positional parameters, but is not allowed +to declare both named and positional parameters. +

+public Query setParameter (int pos, Object value);
+

+Specify positional parameters in your JPQL string using an integer prefixed by a +question mark. You can then populate the Query object +with positional parameter values via calls to the setParameter + method above. The method returns the Query +instance for optional method chaining. +

+EntityManager em = ...
+Query q = em.createQuery("SELECT x FROM Magazine x WHERE x.title = ?1 and x.price > ?2");
+q.setParameter(1, "JDJ").setParameter(2, 5.0);
+List<Magazine> results = (List<Magazine>) q.getResultList();
+

+This code will substitute JDJ for the ?1 +parameter and 5.0 for the ?2 parameter, +then execute the query with those values. +

+public Query setParameter(String name, Object value);
+

+Named parameters are denoted by prefixing an arbitrary name with a colon in your +JPQL string. You can then populate the Query object with +parameter values using the method above. Like the positional parameter method, +this method returns the Query instance for optional +method chaining. +

+EntityManager em = ...
+Query q = em.createQuery("SELECT x FROM Magazine x WHERE x.title = :titleParam and x.price > :priceParam");
+q.setParameter("titleParam", "JDJ").setParameter("priceParam", 5.0);
+List<Magazine> results = (List<Magazine>) q.getResultList();
+

+This code substitutes JDJ for the :titleParam + parameter and 5.0 for the :priceParam + parameter, then executes the query with those values. +

+All input parameters must be single-valued, except in IN expressions +(see Section 2.5.9, “ + JPQL In Expressions + ”), which support the use of collection-valued + input parameters. +

1.8. + Query Hints +

1.8.1. + Locking Hints +
1.8.2. + Lock Timeout Hint +
1.8.3. + Query Timeout Hint +
1.8.4. + Result Set Size Hint +
1.8.5. + Isolation Level Hint +
1.8.6. + Other Fetchplan Hints +
1.8.7. + Database-Specific Hints +
1.8.8. + Named Query Hints +
1.8.9. + Handling of Multiple Similar Query Hints +

+ +

+JPQL provides support for hints which are name/value pairs used to control locking and optimization keywords in SQL. +The following example shows how to use the JPA hint API to set the ReadLockMode +and ResultCount in the OpenJPA fetch plan. This will result in +a database-specific SQL keyword (usually FOR UPDATE) to be emitted into the SQL provided that a +pessimistic LockManager is being used. Additionally, if a DB2 database is being used, +the OPTIMIZE FOR 2 ROWS clause will also be emitted. +

Example 10.1. + Query Hints +

+ +

+...
+Query q = em.createQuery("select m from Magazine m where ... ");
+q.setHint("openjpa.hint.OptimizeResultCount", new Integer(2));
+q.setHint("openjpa.FetchPlan.ReadLockMode","WRITE");
+List r = q.getResultList();
+...
+

+Hints which can not be processed by a particular database or are unknown to OpenJPA are ignored. +Hints known to OpenJPA but supplied with an incompatible value will result in an +IllegalArgumentException being thrown. +

1.8.1. + Locking Hints +

+ +

+To avoid deadlock and optimistic update exceptions among multiple updaters, use a pessimistic LockManager, specified in the persistence unit definition, +and use a hint name of "openjpa.FetchPlan.ReadLockMode" on queries for entities that must be locked for serialization. +The value of ReadLockMode can be either "READ" or "WRITE". +This results in a database-specific locking keyword (usually FOR UPDATE) to be emitted into the SQL. +

+Using a ReadLockMode hint with JPA optimistic locking (i.e. specifying LockManager = "version") will result in the entity version field either being reread at end of transaction in the case of a value of "READ" or the version field updated at end of transaction in the case of "WRITE". You must define a version field in the entity mapping when using a version LockManager and using ReadLockMode. +

Table 10.1. + Interaction of ReadLockMode hint and LockManager +

+ +

+ ReadLockMode +	+ LockManager=pessimistic +	+ LockManager=version +
+ READ +	+ SQL with FOR UPDATE +	SQL without FOR UPDATE; + +reread version field at the end of transaction and check for no change. + +
+ WRITE +	+ SQL with FOR UPDATE +	+ SQL without FOR UPDATE; + +force update version field at the end of transaction + +
+ not specified +	+ SQL without FOR UPDATE +	+ SQL without FOR UPDATE +

1.8.2. + Lock Timeout Hint +

+ +

+To specify a lock timeout hint in milliseconds to those databases that support +it, specify a hint name of "openjpa.LockTimeout" or +"javax.persistence.lock.timeout" with an integer value greater than +zero, or zero for no timeout which is the default behavior. +

1.8.3. + Query Timeout Hint +

+ +

+To specify a query timeout hint in milliseconds to those database drivers that +support it, specify a hint name of "javax.persistence.query.timeout" +with an integer value greater than zero, or zero for no timeout which is the +default behavior. +

1.8.4. + Result Set Size Hint +

+ +

+To specify a result set size hint to those databases that support it, specify a hint name of "openjpa.hint.OptimizeResultCount" with an integer value greater than zero. This causes the SQL keyword OPTIMIZE FOR to be generated. +

1.8.5. + Isolation Level Hint +

+ +

+To specify an isolation level, specify a hint name of "openjpa.FetchPlan.Isolation". The value will be used to specify isolation level using the SQL WITH <isolation> clause for those databases that support it. This hint only works in conjunction with the ReadLockMode hint. +

1.8.6. + Other Fetchplan Hints +

+ +

+Any property of an OpenJPA FetchPlan can be changed using a hint by using a name of the form "openjpa.FetchPlan."<property name>. Valid property names include: +MaxFetchDepth, FetchBatchSize, LockTimeOut, EagerFetchMode, SubclassFetchMode and Isolation. +

1.8.7. + Database-Specific Hints +

+ +

+The hint names "openjpa.hint.MySQLSelectHint" and +"openjpa.hint.OracleSelectHint" can be used to specify a string value +of a query hint that will be inserted into SQL for MySQL and Oracle databases. +See Section 19.1, “ + Using Query Hints with MySQL + ” and +Section 20.1, “ + Using Query Hints with Oracle + ” for examples. +

1.8.8. + Named Query Hints +

+ +

+Hints can also be included as part of a NamedQuery definition. +

Example 10.2. + Named Query using Hints +

+ +

+...
+@NamedQuery(name="magsOverPrice",
+    query="SELECT x FROM Magazine x WHERE x.price > ?1",
+    hints={
+        @QueryHint(name="openjpa.hint.OptimizeResultCount", value="2"),
+        @QueryHint(name="openjpa.FetchPlan.ReadLockMode", value="WRITE")
+    }
+)
+...
+

1.8.9. + Handling of Multiple Similar Query Hints +

+ +

+When similar hints in different prefix scopes are specified in a query, +the following prefix precedence order is used to select the effective hint: +

+javax.persistence.* +
+openjpa.FetchPlan.* +
+openjpa.jdbc.* +
+openjpa.* +

Example 10.3. + Setting Multiple Similar Query Hints +

+ +

+...
+Query q = em.createQuery(.....);
+q.setHint("openjpa.FetchPlan.LockTimeout", 1000);
+q.setHint("javax.persistence.lock.timeout", 2000);
+q.setHint("openjpa.LockTimeout", 3000);
+// Lock time out of 2000 ms is in effect for query q
+...
+

1.9. + Ordering +

+ +

+JPQL queries may optionally contain an order by clause which +specifies one or more fields to order by when returning query results. You may +follow the order by field clause with the asc + or desc keywords, which indicate that ordering +should be ascending or descending, respectively. If the direction is omitted, +ordering is ascending by default. +

+SELECT x FROM Magazine x order by x.title asc, x.price desc
+

+The query above returns Magazine instances sorted by +their title in ascending order. In cases where the titles of two or more +magazines are the same, those instances will be sorted by price in descending +order. +

1.10. + Aggregates +

+ +

+JPQL queries can select aggregate data as well as objects. JPQL includes the +min, max, avg, and +count aggregates. These functions can be used for reporting +and summary queries. +

+The following query will return the average of all the prices of all the +magazines: +

+EntityManager em = ...
+Query q = em.createQuery("SELECT AVG(x.price) FROM Magazine x");
+Number result = (Number) q.getSingleResult();
+

+The following query will return the highest price of all the magazines titled +"JDJ": +

+EntityManager em = ...
+Query q = em.createQuery("SELECT MAX(x.price) FROM Magazine x WHERE x.title = 'JDJ'");
+Number result = (Number) q.getSingleResult();
+

1.11. + Named Queries +

+ +

+Query templates can be statically declared using the NamedQuery + and NamedQueries annotations. For example: +

+@Entity
+@NamedQueries({
+    @NamedQuery(name="magsOverPrice",
+        query="SELECT x FROM Magazine x WHERE x.price > ?1"),
+    @NamedQuery(name="magsByTitle",
+        query="SELECT x FROM Magazine x WHERE x.title = :titleParam")
+})
+public class Magazine {
+    ...
+}
+

+These declarations will define two named queries called magsOverPrice + and magsByTitle. +

+public Query createNamedQuery(String name);
+

+You retrieve named queries with the above EntityManager +method. For example: +

+EntityManager em = ...
+Query q = em.createNamedQuery("magsOverPrice");
+q.setParameter(1, 5.0f);
+List<Magazine> results = (List<Magazine>) q.getResultList();
+

+EntityManager em = ...
+Query q = em.createNamedQuery("magsByTitle");
+q.setParameter("titleParam", "JDJ");
+List<Magazine> results = (List<Magazine>) q.getResultList();
+

1.12. + Delete By Query +

+ +

+Queries are useful not only for finding objects, but for efficiently deleting +them as well. For example, you might delete all records created before a certain +date. Rather than bring these objects into memory and delete them individually, +JPA allows you to perform a single bulk delete based on JPQL criteria. +

+Delete by query uses the same JPQL syntax as normal queries, with one exception: +begin your query string with the delete keyword instead of +the select keyword. To then execute the delete, you call the +following Query method: +

+public int executeUpdate();
+

+This method returns the number of objects deleted. The following example deletes +all subscriptions whose expiration date has passed. +

Example 10.4. + Delete by Query +

+ +

+Query q = em.createQuery("DELETE FROM Subscription s WHERE s.subscriptionDate < :today");
+q.setParameter("today", new Date());
+int deleted = q.executeUpdate();
+

1.13. + Update By Query +

+ +

+Similar to bulk deletes, it is sometimes necessary to perform updates against a +large number of queries in a single operation, without having to bring all the +instances down to the client. Rather than bring these objects into memory and +modifying them individually, JPA allows you to perform a single bulk update +based on JPQL criteria. +

+Update by query uses the same JPQL syntax as normal queries, except that the +query string begins with the update keyword instead of +select. To execute the update, you call the following +Query method: +

+public int executeUpdate();
+

+This method returns the number of objects updated. The following example updates +all subscriptions whose expiration date has passed to have the "paid" field set +to true.. +

Example 10.5. + Update by Query +

+ +

+Query q = em.createQuery("UPDATE Subscription s SET s.paid = :paid WHERE s.subscriptionDate < :today");
+q.setParameter("today", new Date());
+q.setParameter("paid", true);
+int updated = q.executeUpdate();
+

+ +