JPA – Java Persistence Query Language (JPQL) – TEIL I

Java Persistence Query Language (JPQL) ist eine stringbasierte Abfragesprache, die zum Definieren von Abfragen über Entitäten und deren persistenten Zuständen verwendet wird. Es ermöglicht dem Anwendungsentwickler, die Semantik von Abfragen auf portable Weise und unabhängig vom jeweils verwendeten Datenbankschema anzugeben.

Java Persistence Query Language (JPQL) ist nicht nur portierbar, sondern optimiert auch die Abfragemethoden, indem es den Entwicklern ermöglicht, ihre Abfragesprache direkt in die Zielsprache zu kompilierenindem die Ausführung von Abfragen auf die von der Datenbank (oder einem anderen dauerhaften Speicher) bereitgestellten nativen Sprachfunktionen verlagert wird, anstatt dass Abfragen auf der Datenbank ausgeführt werden müssen Laufzeitdarstellung des Entitätsstaates. In diesem Tutorial wird erläutert, wie die Java Persistence Query Language gemäß verwendet wird Java Persistence API 2.1.

EclipseLink unterstützt eine Java Persistence Query Language (JPQL) als einer der Java Persistence API (JPA)-Anbieter und bietet viele Erweiterungen der standardmäßigen JPA Persistence Query Language (JPQL), diese Erweiterungen werden als „JPA Persistence Query Language“ (JPQL) bezeichnet Eclipselink-Abfragesprache.

In diesem Tutorial sollten Sie eine vollständige Abdeckung dessen finden, was die Java Persistence API im Feld „Java Persistence Query Language“ bereitgestellt hat, sowie die wichtigsten Erweiterungen, die von Eclipselink unter dem Namen hinzugefügt wurden, der nach dieser EclipseLink Query Language aufgerufen wurde.

Erforderliche Terminologien

In diesem und den nächsten Tutorials könnten einer oder mehrere der komplexen Begriffe verwendet werden, die verstanden werden sollten, um das JPQL-Konzept einfacher zu machen.

  • Abstraktes Persistenzschema: Dieser Begriff bezieht sich auf die persistente Schemaabstraktion (persistente Entitäten, ihre Zustände und ihre Beziehungen), über die Java Persistence Queries arbeiten. Abfragen über diese persistente Schemaabstraktion werden in Abfragen übersetzt, die über das Datenbankschema ausgeführt werden, dem Entitäten zugeordnet sind.
  • Eine Persistenzeinheit: Dieser Begriff definiert die Menge aller Klassen, die von der Anwendung verknüpft oder gruppiert sind und die bei ihrer Zuordnung zu einer einzelnen Datenbank berechnet werden müssen.

Anweisungstypen

Eine Anweisung in der Java Persistence-Abfragesprache kann entweder eine SELECT-Anweisung, eine Update-Anweisung oder eine DELETE-Anweisung sein. Jede Anweisung der Java Persistence-Abfragesprache kann dynamisch erstellt oder statisch in einer Metadatenanmerkung oder einem XML-Deskriptorelement definiert werden.

Anatomie der Select-Anweisung

Eine Select-Anweisung ist eine Zeichenfolge, die aus den folgenden Klauseln besteht:

  • eine SELECT-Klausel, die den Typ der auszuwählenden Objekte oder Werte bestimmt.
  • eine FROM-Klausel, die Deklarationen bereitstellt, die die Domäne angeben, für die die in den anderen Klauseln der Abfrage angegebenen Ausdrücke gelten.
  • eine optionale WHERE-Klausel, die verwendet werden kann, um die von der Abfrage zurückgegebenen Ergebnisse einzuschränken.
  • eine optionale GROUP BY-Klausel, mit der Abfrageergebnisse in Gruppen zusammengefasst werden können.
  • eine optionale HAVING-Klausel, die das Filtern über aggregierte Gruppen ermöglicht.
  • eine optionale ORDER BY-Klausel, die zum Ordnen der von der Abfrage zurückgegebenen Ergebnisse verwendet werden kann.
  • Eine Select-Anweisung muss immer eine SELECT- und eine FROM-Klausel enthalten.

Klassen Domäne Anatomie

Der Abschnitt zur Klassenanatomie sollte ein vollständiges Bild der Klassen liefern, die die persistente Domäne bilden, über die die SELECT-Anweisung arbeitet. Dieses Tutorial wird hauptsächlich von einer vorherigen persistenten Domäne abhängen, die bereits in den EclipseLink – JPA-Beispielen durchgeführt wurde. Abbildung 1.0 zeigt Ihnen die Klassendomäne.

Klassengestaltung (Verbände)

Abbildung 1.0

Wir haben die folgenden Punkte anhand der vorherigen Abbildung verdeutlicht.

  • Die Entität „Mitarbeiter“ befindet sich in der Mitte der Entitäten.
  • Der Mitarbeiter hat eine OneToOne-Zuordnung (bidirektional) mit einer Adressentität.
  • Der Mitarbeiter verfügt über eine OneToMany-Zuordnung (bidirektional) mit einer Telefonentität.
  • Der Mitarbeiter hat eine ManyToMany-Zuordnung (bidirektional) mit einer Projektentität.
  • Die Lizenz hat eine ManyToOne-(unidirektionale) Zuordnung zu einer Mitarbeiterentität (Der Mitarbeiter hat keine Referenz für die Lizenzentität).

Abfragen mit Select

Das Beispiel, das Sie sehen würden, ist die ständige Verwendung einer statischen Abfrage anstelle einer dynamischen Abfrage (siehe Dynamisch vs. Statisch).

JPAImpl.java

package net.javabeat.eclipselink;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import net.javabeat.eclipselink.data.Address;
import net.javabeat.eclipselink.data.AddressPK;
import net.javabeat.eclipselink.data.ContractDeveloper;
import net.javabeat.eclipselink.data.Developer;
import net.javabeat.eclipselink.data.DriverLicense;
import net.javabeat.eclipselink.data.Employee;
import net.javabeat.eclipselink.data.EmployeePeriod;
import net.javabeat.eclipselink.data.FreelanceDeveloper;
import net.javabeat.eclipselink.data.GlobalProject;
import net.javabeat.eclipselink.data.ICDLComputerLicense;
import net.javabeat.eclipselink.data.License;
import net.javabeat.eclipselink.data.LocalProject;
import net.javabeat.eclipselink.data.Phone;
import net.javabeat.eclipselink.data.PhonePK;
import net.javabeat.eclipselink.data.Project;

public class JPAImpl {
 static EntityManagerFactory factory = null;
 static EntityManager em = null;
 static {
 factory = Persistence.createEntityManagerFactory("EclipseLink-JPA-Installation");
 em = factory.createEntityManager();
 }

 public static void main(String () args){
 // Define a string based query
 String selectQueryStr = "SELECT emp FROM Employee emp";

 // SELECT STATEMENT

 // Create a dynamic query
 Query query = em.createQuery(selectQueryStr);
 // Uses a query object retrieved from the entity manager for acquiring the results
 List<Object> objects = query.getResultList();
 // Looping Over fetched objects
 for(Object obj : objects){
 Employee emp = null;
 if(obj instanceof Employee)
 emp = (Employee) obj;
 else if(obj instanceof Object ()){
 Object () os = (Object ())obj;
 for(Object o : os){
 System.out.println(o);
 }
 }

 if(emp != null){
 System.out.println("Employee Id : "+ emp.getEmployeeId());
 System.out.println("Employee Name : "+ emp.getEmployeeName());
 System.out.println("Employee Period # : Start Date :: "+
 emp.getEmployeePeriod().getStartDate() + " :: End Date " +
 emp.getEmployeePeriod().getEndDate());
 System.out.println("Employee's Address : "+ emp.getAddress().getAddressId());
 System.out.println("Employee's Phones # : "+ emp.getPhones().size());
 System.out.println("Employee's Projects # : "+ emp.getProjects().size());
 }
 }
}
}

  • Der Typ der abgerufenen Objekte kann mithilfe der SELECT-Anweisung bestimmt werden.
  • Durch die Referenzierung einer Employee-Entität ist die Anwendung in der Lage, auf alle Entitäten zuzugreifen, auf die Employee verweist.
  • Obwohl eine Employee-Entität eine Referenz für DriverLicense hat, konnte diese von einem Employee nicht erreicht werden.

Das Ergebnis von JPAImpl.java

Employee Id : 1
Employee Name : John Smith
Employee Period # : Start Date :: Wed Mar 12 00:00:00 GMT+02:00 2014 :: End Date Wed Mar 12 00:00:00 GMT+02:00 2014
Employee's Address : net.javabeat.eclipselink.data.AddressPK@109b2a51
Employee's Phones # : 1
Employee's Projects # : 2

Aber was könnte passieren, wenn wir die SELECT-Anweisung geändert hätten, indem wir sie dazu veranlasst hätten, eine Abfrage nach Attributen (persistenten Feldern) anstelle von Typen (Entitäten) durchzuführen?

JPAImpl.java

package net.javabeat.eclipselink;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import net.javabeat.eclipselink.data.Address;
import net.javabeat.eclipselink.data.AddressPK;
import net.javabeat.eclipselink.data.ContractDeveloper;
import net.javabeat.eclipselink.data.Developer;
import net.javabeat.eclipselink.data.DriverLicense;
import net.javabeat.eclipselink.data.Employee;
import net.javabeat.eclipselink.data.EmployeePeriod;
import net.javabeat.eclipselink.data.FreelanceDeveloper;
import net.javabeat.eclipselink.data.GlobalProject;
import net.javabeat.eclipselink.data.ICDLComputerLicense;
import net.javabeat.eclipselink.data.License;
import net.javabeat.eclipselink.data.LocalProject;
import net.javabeat.eclipselink.data.Phone;
import net.javabeat.eclipselink.data.PhonePK;
import net.javabeat.eclipselink.data.Project;

public class JPAImpl {
 static EntityManagerFactory factory = null;
 static EntityManager em = null;
 static {
 factory = Persistence.createEntityManagerFactory("EclipseLink-JPA-Installation");
 em = factory.createEntityManager();
 }

 public static void main(String () args){
 // Define a string based query
 String selectQueryStr = "SELECT emp.employeeId,emp.employeeName FROM Employee emp";

 // SELECT STATEMENT

 // Create a dynamic query
 Query query = em.createQuery(selectQueryStr);
 // Uses a query object retrieved from the entity manager for acquiring the results
 List<Object> objects = query.getResultList();
 // Looping Over fetched objects
 for(Object obj : objects){
 Employee emp = null;
 if(obj instanceof Employee)
 emp = (Employee) obj;
 else if(obj instanceof Object ()){
 Object () os = (Object ())obj;
 for(Object o : os){
 System.out.println(o);
 }
 }

 if(emp != null){
 System.out.println("Employee Id : "+ emp.getEmployeeId());
 System.out.println("Employee Name : "+ emp.getEmployeeName());
 System.out.println("Employee Period # : Start Date :: "+
 emp.getEmployeePeriod().getStartDate() + " :: End Date " +
 emp.getEmployeePeriod().getEndDate());
 System.out.println("Employee's Address : "+ emp.getAddress().getAddressId());
 System.out.println("Employee's Phones # : "+ emp.getPhones().size());
 System.out.println("Employee's Projects # : "+ emp.getProjects().size());
 }
 }

}

}
  • Ein SELECT kann zum Definieren von Abrufen von Attributen/Typen oder beidem verwendet werden.

Das Ergebnis von JPAImp.java

1
John Smith

Aktualisieren und Löschen

Bei der Verwendung von Abfragen wird nicht nur die SELECT-Anweisung berücksichtigt, sondern sie können auch für die Verarbeitung einer Vielzahl von Änderungs- und Löschanweisungen verwendet werden.

Anatomy of Update-Anweisung

  • Der Aufbau der Update-Anweisung ist identisch mit dem in der SQL-Datenbank definierten.
  • Eine UPDATE-Klausel, die die Entitäten definiert, auf die sich die Update-Anweisung auswirkt.
  • Eine SET-Klausel, die durch Kommas getrennte Paare (Eigenschaft, Wert) für die zu ändernden Eigenschaften bereitstellt.
  • Eine WHERE-Klausel, die die Bedingungen bereitstellt, die auf den aktualisierten Entitäten basieren.

JPAImpl.java

package net.javabeat.eclipselink;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import net.javabeat.eclipselink.data.Address;
import net.javabeat.eclipselink.data.AddressPK;
import net.javabeat.eclipselink.data.ContractDeveloper;
import net.javabeat.eclipselink.data.Developer;
import net.javabeat.eclipselink.data.DriverLicense;
import net.javabeat.eclipselink.data.Employee;
import net.javabeat.eclipselink.data.EmployeePeriod;
import net.javabeat.eclipselink.data.FreelanceDeveloper;
import net.javabeat.eclipselink.data.GlobalProject;
import net.javabeat.eclipselink.data.ICDLComputerLicense;
import net.javabeat.eclipselink.data.License;
import net.javabeat.eclipselink.data.LocalProject;
import net.javabeat.eclipselink.data.Phone;
import net.javabeat.eclipselink.data.PhonePK;
import net.javabeat.eclipselink.data.Project;

public class JPAImpl {
 static EntityManagerFactory factory = null;
 static EntityManager em = null;
 static {
 factory = Persistence.createEntityManagerFactory("EclipseLink-JPA-Installation");
 em = factory.createEntityManager();
 }

public static void main(String () args){

String updateQueryStr = "UPDATE Employee emp SET emp.employeeName="Gilbert Samouel" WHERE emp.employeeId = '1'";

// UPDATE STATEMENT
 em.getTransaction().begin();
 Query query = em.createQuery(updateQueryStr);
 int rowsAffected = query.executeUpdate();
 System.out.print("Number of rows affected Are : "+rowsAffected);
 em.getTransaction().commit();

}

}

Das Ergebnis der Ausführung

1
John Smith
Number of rows affected Are : 1

Die Änderung innerhalb der Datenbank

Abfrage aktualisieren

  • Die Update-Anweisung bedeutet eine Änderung, die innerhalb einer Transaktion angewendet werden sollte.

Anatomie der Löschanweisung

  • Der Aufbau der Löschanweisung ist identisch mit dem in der SQL-Datenbank definierten.
  • Eine DELETE-Klausel.
  • Eine FROM-Klausel, die zum Definieren der zu entfernenden Entitäten verwendet wird.
  • Eine WHERE-Klausel, die die Bedingungen bereitstellt, die auf den entfernten Entitäten basieren.

JPAImpl.java

package net.javabeat.eclipselink;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import net.javabeat.eclipselink.data.Address;
import net.javabeat.eclipselink.data.AddressPK;
import net.javabeat.eclipselink.data.ContractDeveloper;
import net.javabeat.eclipselink.data.Developer;
import net.javabeat.eclipselink.data.DriverLicense;
import net.javabeat.eclipselink.data.Employee;
import net.javabeat.eclipselink.data.EmployeePeriod;
import net.javabeat.eclipselink.data.FreelanceDeveloper;
import net.javabeat.eclipselink.data.GlobalProject;
import net.javabeat.eclipselink.data.ICDLComputerLicense;
import net.javabeat.eclipselink.data.License;
import net.javabeat.eclipselink.data.LocalProject;
import net.javabeat.eclipselink.data.Phone;
import net.javabeat.eclipselink.data.PhonePK;
import net.javabeat.eclipselink.data.Project;

public class JPAImpl {
 static EntityManagerFactory factory = null;
 static EntityManager em = null;
 static {
 factory = Persistence.createEntityManagerFactory("EclipseLink-JPA-Installation");
 em = factory.createEntityManager();
 }

public static void main(String () args){
 String deleteQueryStr1 = "DELETE FROM DriverLicense lic WHERE lic.employee.employeeId = '1'";

// DELETE STATEMENT
 em.getTransaction().begin();
 // Remove the DriverLicense
 Query query = em.createQuery(deleteQueryStr1);
 int rowsAffected = query.executeUpdate();
 System.out.print("Number of rows affected Are : "+rowsAffected);
 em.getTransaction().commit();

}

}

Das Ergebnis der Ausführung

Number of rows affected Are : 1
  • Versuchen Sie nicht, die DriverLicense-Entität zu entfernen, indem Sie die License-Entität erwähnen, da License eine zugeordnete Superklasse ist und zum Teilen von Zuordnungsinformationen und dauerhaften Zuständen verwendet wird (siehe Zugeordnete Superklasse).
  • Das Entfernen einer Entität betrachtet eine Transaktion.

Zusammenfassung

Einer der spannenden Teile innerhalb der Java Persistence API ist eine Java Persistence Query Language, die eine (stringbasierte Abfrage) zum Abfragen der persistenten Zieldomäne, z. B. einer Datenbank, bereitstellt. Dieses Tutorial bietet Ihnen eine grundlegende Einführung in die Verwendung der Java Persistence Query Language für die gängigsten Funktionen SELECT, UPDATE und DELETE.

Die nächsten kommenden Tutorials sollten attraktivere Teile abdecken, die sich auf JPQL beziehen, und daher sprechen wir über Eclipselink. Außerdem sollte es hervorragende Tutorials und Übungen zu dem bieten, was Eclipselink hinzugefügt hat.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen