JPQL Java Persistence Query Language Cornelius Zühl Arend Kühle Komponentenarchitektur WS 08/09 Java Persistence Query Language

Java Persistence API JPA import javax.persistence Persistence Entity Objektrelationale Metadaten Java-Annotationen oder XML-Datei Java Persistence Query Language (JPQL) ähneln syntaktisch SQL-Abfragen bezieht sich auf Entitäten Java Persistence Query Language

Java Persistence API JPA persistance.xml EntityManager Hibernate Objektoperationen find merge persist update remove JPQL Query API Zugang zu den Datenbankfunktionalitäten erhält man mittels dem EntityManager. • Es gibt 2 unterschiedliche Arbeitsweisen: – Eher objektorientiert mit den Operationen „persist“, „update“, „remove“, „find“ und „merge“. – Eher relational mit der Datenbanksprache JPQL und der Query-API. • Beide Arbeitsweisen beziehen sich letztendlich auf Datenobjekte -> Entities und deren Life-Cycle Objektoperationen Entityobjekte stehen im Mittelpunkt der Datenbankoperationen: persist, remove, merge, find • Fortsetzung der Operationen über Beziehungen hinweg (Transitive Persistenz) Cascade • Ownership Datenbanksprache JPQL steht im Mittelpunkt der Query-API: select, update, delete • Entityobjekte in Abfrageergebnissen. Hibernate und Oracle TopLink bilden nun Implementierungen der Java Persistence API. Oracle TopLink Entity Java Persistence Query Language

JPQL Syntax Query select u from User u SQL Syntaxkriterien werden genutzt and or < > = <= <> ( ) select u.name from User u where (u.age > 18 and u.age <= 65) or u.age = 83 Nutze (kurze) Aliase Natürlich kann das jeder halten wie er möchte, doch vielleicht ist bei dem ein oder anderen noch nicht angekommen, dass man auch in der JPQL mit Aliasen arbeiten kann. Verwendet man einen Alias sollte er dann meiner Meinung nach aber auch kurz sein, denn dieser soll Arbeit erleichtern und nicht zu langer und fehleranfälliger Tipparbeit führen: Erweitert um Objektorientierte Befehle is empty, is null, not … Java Persistence Query Language

JPQL Statement JPQL Statement select update delete Query q = em.createQuery („select u from User u"); List<User> userList = q.getResultList(); Kurze aliase verwenden! Case sensitiv: entity und identivier Query q = em.createQuery ("update User u set u.name = ‘Max‘ where u.name = ‘Moritz‘"); int updated = q.executeUpdate(); Query q = em.createQuery ("delete u from User u where u.name = ‘Busch‘ "); int deleted = q.executeUpdate(); Java Persistence Query Language

Datenabfrage Datenabfrage EntityManager Primary Key Query API JPQL EntityManager em; em.find(...); EntityManager Primary Key Query API JPQL Query q; Erste Anlaufstelle aller Abfragen ist der EntityManager. • Abfragen anhand des Primärschlüssels unterstützt der EntityManager direkt. -> Objektoperationen Alle sonstigen Abfragen erfolgen mittels der Query-API und der Datenabfragesprache JPQL. Die Query-API kennt 3 Querytypen – Query: JPQL Abfrage – NativeQuery: Datenbankabhänige SQL-Abfrage – NamedQuery: In Annotationen hinterlegte JPQL Abfrage Query q = em.createQuery(...) NativeQuery q = em.createNativeQuery(...) NamedQuery q = em.createNamedQuery(...) Java Persistence Query Language

JPQL Funktionen select u from User u where concat(u.name, 's') = 'Walters' select u from User u where substring(u.name, 1, 1) = 'W' select u from User u where trim(leading 'a' FROM u.name) = 'W' select u from User u where lower(u.name) = 'walter' select u from User u where upper(u.name) = 'WALTER' select u from User u where length(u.name) = 6 select u from User u where locate('a', u.name) = 2 select u from User u where abs(u.age) >= 5.00 select u from User u where sqrt(u.age) >= 1000 select u from User u where mod(u.age, 10) = 0 Java Persistence Query Language

Aggregatsfunktionen MIN, MAX, AVG, COUNT und SUM Query q = em.createQuery("select min(u.age), max(u.age), avg(u.age), sum(u.age) from User u”); Object[] stats = (Object[]) q.getSingleResult(); Aggregatsffunktionen/Summenfunktionen werden unterstützt Es werden fünf sogenannte Aggregatfunktionen, manchmal auch unter dem Begriff Summenfunktionen bekannt, in JPQL unterstützt: AVG, COUNT, MIN, MAX uns SUM. Sie können direkt auf ein selektiertes Ergebnis verwendet werden Java Persistence Query Language

Polimorphische Queries Auto Fiat Opel Renault Kurze aliase verwenden! Case sensitiv: entity und identivier Query q = em.createQuery („select a from Auto a where a.price < 10000"); List<User> autoList = q.getResultList(); Java Persistence Query Language

Prepared Statements Entity Object Java Persistence Query Language em.createQuery("select u from User u where name = " +name+ " and age > " +age); public List<User> findUsers(String name, int age) { Query q = em.createQuery(" Select u from User u where name = :name and age > :age"); q.setParameter("name", name); q.setParameter("age", age); return List<User> users = q.getResultList(); } public List<User> findUsers(String name, int age) { Query q = em.createQuery(" select u from User u where name = ?1 and age > ?2"); q.setParameter(1, name); q.setParameter(2, age); return List<User> users = q.getResultList(); } Verwende Prepared Statements Eigentlich ein abolut alter Hut, allerdings doch noch nicht in alle Köfen angekommen: Prepared Statements. Auch mit der JPQL ist es mämlich Prepared Statements zu verwenden. Anstatt seine Query wie folgt aufzubauen: view plain copy to clipboard print ? Sollte man die Query API verwenden und die Parameter durch Platzhalter ersetzen Als Parameter kann man auch direkt Entity Objekte verwenden. Nehmen wir an wir haben eine Adresse und wollen den User finden der diese Adresse angegeben hat. Die Beziehung zwischen den Entitäten User und Address ist somit OneToOne „select u“ kann man fallen lassen, dann wird automatisch das Objekt geholt Entity Object public User findUserByAddress(Address address) { Query q = em.createQuery(" select u from User u where u.address = :address "); q.setParameter(„address", adedress); return q.getSingleResult(); } Java Persistence Query Language

Begrenzen der Ergebnismenge Query q = em.createQuery("select u from User u"); q.setFirstResult(30); q.setMaxResults(10); List<User> users = q.getResultList(); public List<User> findUsers(int firstRow, int maxResults) { Query q = em.createQuery("select u from User u"); q.setFirstResult(firstRow); q.setMaxResults(maxResults); return List<User> users = q.getResultList(); } Begrenze die Ergebnismenge Gerade bei Listen in denen geblättert wird oder wenn man nur einen kleinen Teil einer Liste zeigen möchte empfiehlt es sich nicht die komplette Objektliste zu laden und anschließend nur 10 Objekte davon anzuzeigen. Alle Datenbanken besitzen eine Art von Ergebnismengenlimitierung. Wie auch immer das die Datenbank macht - es kann losgelöst davon über die JPA Query API mitgegeben werden. Im folgenden Beispiel soll aus der Liste aller User beginnend bei der 30. Zeile 10 Zeilen/User zurückgeliefert werden: Java Persistence Query Language

Konkrete Daten statt komplette Objekte Query q = em.createQuery("select u.id, u.name from User u"); List<Object[]> result = q.getResultList(); List<User> users = new ArrayList<User>(result.size()); for(Object[] objAr : result){ Long userId = objAr[0]; String userName = objAr[1]; User u = new User(); u.setUserId(userId); u.setUserName(userName); users.add(u); } public class User { public User(String id, String name) { this.id = id; this.name = name; }} Query q = em.createQuery("select new User(u.id, u.name) from User u"); List<User> result = q.getResultList(); Konkrete Daten anstatt komplette Objekte laden Eines der größten (Performance) Fehler/Probleme die man machen oder haben kann ist komplette Objektstrukturen zu laden obwohl vielleicht nur ein kleiner Teil des Objektes zur Anzeige gebracht wird und das Objekt keine weitere Bedeutung hat. Gerade bei sehr großen Listen über die geblättert wird reicht oft die Id und ein Anzeigetext/wert als Rückgabewert des JPQL Aufrufes. Es spricht bei der Verwendung von JPA überhaupt nichts dagegen performanceoptimiert nur Teile einer Entitä für die Anzeige zu laden und erst wenn man konkret auf eine bestimmte Entität zugreifen möchte diese anschließend noch einmal komplett, also das ganze Objekt, zu laden. Hat man einen Konstruktor der die entsprechenden Attribute entgegennimmt kann man sich die Sache sogar noch wesentlich vereinfachen Um nicht mit den Entitäten durcheinander zu kommen bietet es sich auch an ein UserDo zu erstellen, welches lediglich die benötigten Attribute enthält. Java Persistence Query Language

Named Queries @Entity() @NamedQuery (name=„findAllUsers", query="select u from User u") public class User { // ... } @Entity() @NamedQuerys ({ @NamedQuery (name=„findAllUsers", query="select u from User u"), @NamedQuery (name=„findAdults", query="select u from User u where age > 17"), @NamedQuery (name=„getAverageAge", query="select avg(u.age) from User u") }) public class User { // ... } public List<User> getUser() { Query query = em.createNamedQuery("findAllUsers"); // Query query = em.createNamedQuery("User.findAllUsers"); List<User> userList = query.getResultList(); return userList; } Java Persistence Query Language

Exception Handling getSingleResult() javax.persistence.NoResultException javax.persistence.NoneUniqueResultException java.lang.IllegalStateException getResultList() java.lang.IllegalStateException Java Persistence Query Language

Und nun zur Praxis Vorführung Tools Queries Tipps Quellen http://edocs.bea.com/kodo/docs41/full/html/ejb3_overview_query.html http://java.sun.com/mailers/techtips/enterprise/2006/TechTips_Oct06.html http://javathreads.de/2008/04/jpa-mit-hibernate-einfuehrung/ http://www.kunkelgmbh.de/jpa/ Java Persistence Query Language