5/2/2017. Querying. Querying. Querying. Entities can be retrieved using EntityManager.find() when the primary key is known

Size: px

Start display at page:

Download "5/2/2017. Querying. Querying. Querying. Entities can be retrieved using EntityManager.find() when the primary key is known"

Edwin Wilkinson
6 years ago
Views:

1 Querying Software Architectures and Methodologies - Entities can be retrieved using EntityManager.find() when the primary key is known JPA: Querying to obtain the primary key either the key is natural or some query is needed that retrieves Entities (or Entity primary keys) as a result of a search by some criteria Dipartimento di Ingegneria dell'informazione Laboratorio Tecnologie del Software Università di Firenze enrico.vicario@unifi.it, 1 Querying Querying JPA provides two ways for expressing queries querying involves 3 steps Java Persistence Query Language (JPQL) a database-independent query language operates on the logical entity model as opposed to the physical data model the usual way queries may also be expressed in SQL to take advantage of the underlying database usually not recommended create the query with any restriction or projection of data to retrieve bind runtime arguments to query parameters the same query can be reused with changing settings execute the query on the database and retrieve data control is provided on how the query is executed and how data should be retrieved into memory 2 3

2 Creating the query Creating the query JPA provides 2 interfaces to create and execute queries A query may be defined dynamically in the javax.persistence package Query by passing the JPQL query string and expected result type to the createquery() method of the EntityManager interface (TBD: queries may also be pre-compiled, for performance) the result type is an untyped Object requires casting, and may be unsafe TypedQuery untyped query Query query = entitymanager.createquery( results are typed type checking of results is performed in the execution the recommended way "from Order where user = :myuser"); typed query (adds Class specification) TypedQuery<Order> query = entitymanager.createquery( In both cases, the query is checked at execution "from Order where user = :myuser", Order.class); so, testing is anyway required 4 5 Binding Parameters Binding Parameters a query may include parameters Query query = entitymanager.createquery( :myuser is a parameter "from Order where user = :myuser"); parameters binding occurs at the execution of the query values can be varied along the execution the same query can be executed more than once with different parameters if parameters are input as strings querying is exposed to SQL injection setparameter() method adds escape parameters, and more Query query = entitymanager.createquery("from Order where user = :myuser"); query.setparameter("myuser", auser); auser of type User, can be passed as parameter of the query JPA engine translates the query and matches automatically the primary key of the entity to the primary key of the column 6 7

3 when the query has been defined and parameters set getsingleresult() or getresultlist() invoke the execution available in both the Query and TypedQuery interfaces getsingleresult() executes a SELECT query that returns a single result of type Object, if invoked on a Query of the specified class, if invoked on a TypedQuery if no result is available throws a NoResultException If multiple results are retrieved throws a NonUniqueResultException exception 8 9 getresultlist() executes a SELECT query and returns the query results as a List a List of Object for a Query, of the specified Class for a TypedQuery the List can be empty, if no results are retrieved TypedQuery<Order> query = entitymanager.createquery( "from Order where user = :myuser", Order.class); query.setparameter("myuser", auser); List<Order> resultlist = query.getresultlist(); 10 11

4 The Query interface also features methods for executing Update and Delete queries delete operations can better be implemented using EntityManager. remove() update operations can better be implemented using the dirty checking provided by the Persistence Context TypedQuery<Order> query = entitymanager.createquery( "from Order where user = :myuser", Order.class); query.setparameter("myuser", auser); Order result = query.getsingleresult(); This will likely throw an exception (since a single result is expected but the query is not likely to return a single result) JPQL Syntax JPQL Java Persistence Query Language (JPQL) is the standard query language of JPA is a portable query language: queries can be compiled to SQL dialects of all major database servers designed to combine syntax and query semantics of SQL with the expressiveness of an object-oriented language JPQL is not SQL! despite (intentional) similarities in keywords and structure, there are very important differences JPQL is a language for querying entities Instead of tables and rows, the currency of the language is entities and objects JPQL queries refer to entities and their relationships refers to Entities defined in the object model, not to the physical database model which is not necessarily known to express a query 14 15

5 Select Queries Select Queries The overall form of a select query is as follows: The overall form of a select query is as follows: SELECT <select_expression> FROM <from_clause> [WHERE <conditional_expression>] [ORDER BY <order_by_clause>] SELECT <select_expression> FROM <from_clause> [WHERE <conditional_expression>] [ORDER BY <order_by_clause>] The SELECT clause defines the format of the query results the FROM clause defines the entity (or entities) from which the results will be obtained Select Queries Select Queries example: retrieves all the User in the database example: retrieves all the User in the database SELECT u FROM User u SELECT u FROM User u 18 Alias for the entity User 19

6 Select Queries Select Clause Path Expressions example: retrieves all the User in the database path expressions are the building blocks of queries used to navigate out from an entity, either across a relationship to another entity (or collection of entities) or to one of the persistent properties of an entity SELECT u FROM User u Indicates that the result type of the query is the Employee entity state field path navigation that results in one of the persistent state fields (either field or property) of an entity single-valued association path navigation that leads to a single entity collection-valued association path 20 navigation to a collection of entities 21 Select Clause Path Expressions Select Clause Path Expressions example: a path expression that selects all the StoreOrders for a particular item and returns the User associated example: a path expression that selects all the StoreOrders for a particular item and returns the User associated This maybe will result in duplicate object, adding a distinct will solve the problem SELECT s.buyer SELECT DISTINCT s.buyer 22 23

7 Select Clause Path Expressions Select Clause Path Expressions path expressions can be chained together to traverse complex entity graphs as long as the path moves from left to right across single-valued associations a path cannot continue from a state field or collection-valued association example: a path expression that selects all the StoreOrders in the database and returns the username of the associated User SELECT s.buyer.username Joins the FROM clause declares one or more identification variables optionally derived from joined relationships form the domain over which the query should draw its results syntax of the FROM clause one or more identification variables and join clause declarations a join is a query that combines results from multiple entities Joins in JPQL queries is logically equivalent to the SQL join once the query is translated to SQL, it is quite likely that the joins between entities will produce similar joins among the tables to which the entities are mapped 26 27

8 - Joins Implicit Association Joins JPQL provide three main ways of expressing inner and outer joins: implicit association join ordinary join in the FROM clause theta-style join in the WHERE clause implicit association joins we saw this type of join in the previous examples navigating an entity using a path expression like this will translate in SQL as a JOIN query SELECT s.buyer.username Join in the FROM clause Theta-style join in the where Clause Join expressed in an explicit way in the FROM clause example: the same query from earlier, but the join explicit theta-style join in the Where clause a Cartesian product with a join condition in the WHERE clause, which is applied on the product to restrict the result SELECT b.username JOIN s.buyer b SELECT u.username, User u WHERE s.buyer = u and s.item = :item 30 31

9 Inheritance & Polymorphism Inheritance & Polymorphism JPA supports inheritance between entities as a result, the query language supports polymorphic results multiple subclasses of an entity can be returned by the same query example Inheritance & Polymorphism Inheritance & Polymorphism example: returns all the items in the database restrict the query to a particular subclass entity specify the subclass in the FROM clause SELECT i FROM Item i SELECT d FROM DownloadableItem d SELECT p FROM Product p 34 35

10 Where Clause Where Clause WHERE clause of a query is used to specify filtering conditions to reduce the result set The definition of the WHERE clause is simply the keyword WHERE, followed by a conditional expression JPQL supports a powerful set of conditional expressions Input parameters for queries can be specified using either positional or named notation Positional notation is defined by prefixing the variable number with a question mark (not used) SELECT s SELECT s WHERE s.item =?1 36 Positional notation Named notation 37 Where Clause Order By Clause Comparison operators in WHERE clause can be used to create sophisticated queries The most used operators are: =, >, >=, <, <=, <> [NOT] BETWEEN [NOT] LIKE [NOT] IN IS [NOT] NULL These are all similar to the correspondent SQL expressions, so their meaning can be easily understand Queries can optionally be sorted use one or more expressions consisting of identification variables, result variables, a path expression resolving to a single entity, or a path expression resolving to a persistent state field SELECT u FROM User u ORDER BY u.username 38 39

11 Order By Clause Query Paging optional keywords ASC or DESC after the expression can be used to indicate ascending or descending sorts, default sort order is ascending pagination technique Users may see the result of their search request as a page (for example, for specific Items in our store) the page shows a limited subset (say, 10 Items) at a time, and users can navigate to next and previous pages manually Query Paging interface Query provides methods to paginate results, permits specification of the offset and the limit of our query Query query = entitymanager.createquery( query.setfirstresult(10); query.setmaxresult(20); "from Order where user = :myuser"); The result of this query will start from the 10th item and will show 20 items 42

5/2/2017. The entity manager. The entity manager. Entities lifecycle and manipulation

5/2/2017. The entity manager. The entity manager. Entities lifecycle and manipulation Entities lifecycle and manipulation Software Architectures and Methodologies - JPA: Entities lifecycle and manipulation Dipartimento di Ingegneria dell'informazione Laboratorio Tecnologie del Software