JPA - JPQL

In diesem Kapitel werden über JPQL und wie es funktioniert mit Ausdauer-Einheiten. In diesem Kapitel werden die gegebenen Beispiele folgen dem gleichen Pakethierarchie, die wir im vorigen Kapitel verwendet.

Java Persistence Query-Sprache

JPQL steht für Java Persistence Query Language. Es wird verwendet, um Abfragen gegen Entitäten zu schaffen, um in einer relationalen Datenbank zu speichern. JPQL wird basierend auf SQL-Syntax entwickelt. Aber es wird nicht auf die Datenbank direkt.

JPQL können Daten unter Verwendung SELECT-Klausel abzurufen, können tut Massen Updates mit UPDATE und DELETE-Klausel.

Suchstruktur

JPQL Syntax ist sehr ähnlich der Syntax von SQL. Mit SQL-ähnliche Syntax ist ein Vorteil, da SQL ist einfach und vielfältig eingesetzt. SQL arbeitet direkt gegen relationalen Datenbanktabellen, Datensätzen und Feldern, während JPQL arbeitet mit Java-Klassen und Instanzen.

Zum Beispiel, ein JPQL Abfrage kann eine Entität Objekt eher als Feldergebnis aus einer Datenbank festgelegt, wie mit SQL abrufen. Die JPQL Abfrage Struktur wie folgt.

SELECT ... FROM ...
[WHERE ...]
[GROUP BY ... [HAVING ...]]
[ORDER BY ...]

Die Struktur der JPQL DELETE und UPDATE-Abfragen sind wie folgt.

DELETE FROM ... [WHERE ...]
 
UPDATE ... SET ... [WHERE ...]

Scalar und Aggregationsfunktionen

Scalar Funktionen geben resultierenden Werte basierend auf Eingabewerte. Statistikfunktionen geben die resultierenden Werte durch Berechnung der Eingangswerte.

Wir werden das gleiche Beispiel Mitarbeitermanagement, wie im vorherigen Kapitel verwenden. Hier werden wir über die Service-Klassen mit Skalar und Aggregatfunktionen von JPQL gehen.

Lassen Sie uns Nehmen wir an, die jpadb.employee Tabelle enthält folgende Aufzeichnungen.

Erstellen Sie eine Klasse mit dem Namen ScalarandAggregateFunctions.java unter com.howcodex.eclipselink.service -Paket wie folgt.

package com.howcodex.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class ScalarandAggregateFunctions 
{
   public static void main( String[ ] args ) 
   {
      EntityManagerFactory emfactory = Persistence.
      createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.
      createEntityManager();
      //Scalar function
      Query query = entitymanager.
      createQuery("Select UPPER(e.ename) from Employee e");
      List<String> list=query.getResultList();

      for(String e:list)
      {
         System.out.println("Employee NAME :"+e);
      }
      //Aggregate function
      Query query1 = entitymanager.
      createQuery("Select MAX(e.salary) from Employee e");
      Double result=(Double) query1.getSingleResult();
      System.out.println("Max Employee Salary :"+result);
   }
}

Nach der Kompilierung und Ausführung des oben genannten Programms werden Sie die folgende Ausgabe auf der Konsole Panel von Eclipse-IDE zu bekommen.

Employee NAME :GOPAL
Employee NAME :MANISHA
Employee NAME :MASTHANVALI
Employee NAME :SATISH
Employee NAME :KRISHNA
Employee NAME :KIRAN
Max Employee Salary :40000.0

Zwischen, und wie Keywords

Zwischen, und, und Wie sind die wichtigsten Stichworte der JPQL. Diese Schlüsselwörter sind verwendet nach Where-Klausel in einer Abfrage.

Erstellen Sie eine Klasse mit dem Namen BetweenAndLikeFunctions.java unter com.howcodex.eclipselink.service -Paket wie folgt:

package com.howcodex.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.howcodex.eclipselink.entity.Employee;

public class BetweenAndLikeFunctions 
{
   public static void main( String[ ] args ) 
   {
      EntityManagerFactory emfactory = Persistence.
      createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.
      createEntityManager();
      //Between
      Query query = entitymanager.
      createQuery( "Select e " +
      "from Employee e " +
      "where e.salary " +
      "Between 30000 and 40000" )
      List<Employee> list=(List<Employee>)query.getResultList( );
 
      for( Employee e:list )
      {
         System.out.print("Employee ID :"+e.getEid( ));
         System.out.println("\t Employee salary :"+e.getSalary( ));
      }

      //Like
      Query query1 = entitymanager.
      createQuery("Select e " +
      "from Employee e " +
      "where e.ename LIKE 'M%'");
      List<Employee> list1=(List<Employee>)query1.getResultList( );
      for( Employee e:list1 )
      {
         System.out.print("Employee ID :"+e.getEid( ));
         System.out.println("\t Employee name :"+e.getEname( ));
      }
   }
}

Nach dem Kompilieren und Ausführen des obigen Programms, werden Sie die folgende Ausgabe in der Konsole Panel von Eclipse-IDE zu bekommen.

Employee ID :1201	 Employee salary :40000.0
Employee ID :1202	 Employee salary :40000.0
Employee ID :1203	 Employee salary :40000.0
Employee ID :1204	 Employee salary :30000.0
Employee ID :1205	 Employee salary :30000.0
Employee ID :1206	 Employee salary :35000.0

Employee ID :1202	 Employee name :Manisha
Employee ID :1203	 Employee name :Masthanvali

Bestell

Um die Datensätze in JPQL bestellen, verwenden wir die ORDER BY-Klausel. Die Verwendung dieser Klausel ist die gleiche wie in SQL, aber es befasst sich mit Entitäten. Das folgende Beispiel zeigt, wie Sie die ORDER BY-Klausel verwenden.

Erstellen Sie eine Klasse Ordering.java unter com.howcodex.eclipselink.service -Paket wie folgt:

package com.howcodex.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.howcodex.eclipselink.entity.Employee;

public class Ordering 
{
   public static void main( String[ ] args ) 
   {
      EntityManagerFactory emfactory = Persistence.
      createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.
      createEntityManager();
      //Between
      Query query = entitymanager.
      createQuery( "Select e " +
      "from Employee e " +
      "ORDER BY e.ename ASC" );
      List<Employee> list=(List<Employee>)query.getResultList( );

      for( Employee e:list )
      {
         System.out.print("Employee ID :"+e.getEid( ));
         System.out.println("\t Employee Name :"+e.getEname( ));
      }
   }
}

Kompilieren und Ausführen des obigen Programms, werden Sie die folgende Ausgabe in der Konsole Panel von Eclipse-IDE zu bekommen.

Employee ID :1201	 Employee Name :Gopal
Employee ID :1206	 Employee Name :Kiran
Employee ID :1205	 Employee Name :Krishna
Employee ID :1202	 Employee Name :Manisha
Employee ID :1203	 Employee Name :Masthanvali
Employee ID :1204	 Employee Name :Satish

benannte Abfragen

Ein @NamedQuery Anmerkung wird als Abfrage mit einer vordefinierten Abfrage-String, die unveränderbar ist definiert. Im Gegensatz zu dynamischen Abfragen, kann benannten Abfragen Code Organisation durch die Trennung der JPQL Query-Strings von POJO verbessern. Es geht auch besitzen die Abfrageparameter anstatt die Einbettung der Literale dynamisch in die Query-String und erzeugt daher effizienter Abfragen.

Zunächst von alle, hinzufügen @NamedQuery Anmerkung zu der Employee-Entität Klasse mit dem Namen Employee.java unter com.howcodex.eclipselink.entity -Paket wie folgt:

package com.howcodex.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@Table
@NamedQuery(query = "Select e from Employee e where e.eid = :id", 
name = "find employee by id")
public class Employee 
{
   @Id
   @GeneratedValue(strategy= GenerationType.AUTO) 
   private int eid;
   private String ename;
   private double salary;
   private String deg;
   public Employee(int eid, String ename, double salary, String deg) 
   {
      super( );
      this.eid = eid;
      this.ename = ename;
      this.salary = salary;
      this.deg = deg;
   }
   public Employee( ) 
   {
      super();
   }

   public int getEid( ) 
   {
      return eid;
   }
   public void setEid(int eid)  
   {
      this.eid = eid;
   }

   public String getEname( ) 
   {
      return ename;
   }
   public void setEname(String ename) 
   {
      this.ename = ename;
   }

   public double getSalary( ) 
   {
      return salary;
   }
   public void setSalary(double salary) 
   {
      this.salary = salary;
   }

   public String getDeg( ) 
   {
      return deg;
   }
   public void setDeg(String deg) 
   {
      this.deg = deg;
   }
   @Override
   public String toString()
   {
      return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
      + salary + ", deg=" + deg + "]";
   }
}

Erstellen Sie eine Klasse mit dem Namen NamedQueries.java unter com.howcodex.eclipselink.service -Paket wie folgt:

package com.howcodex.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.howcodex.eclipselink.entity.Employee;

public class NamedQueries 
{
   public static void main( String[ ] args ) 
   {
      EntityManagerFactory emfactory = Persistence.
      createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.
      createEntityManager();
      Query query = entitymanager.createNamedQuery(
      "find employee by id");
      query.setParameter("id", 1204);
      List<Employee> list = query.getResultList( );
      for( Employee e:list )
      {
         System.out.print("Employee ID :"+e.getEid( ));
         System.out.println("\t Employee Name :"+e.getEname( ));
      }
   }
}

Nach dem Kompilieren und Ausführen des obigen Programms, werden Sie die folgende Ausgabe in der Konsole Panel von Eclipse-IDE zu bekommen.

Employee ID :1204	 Employee Name :Satish

Nach dem Hinzufügen alle die oben genannten Klassen die Pakethierarchie Aussehen wie folgt:

Eager und Lazy Abholen

Das wichtigste Konzept von JPA ist ein Duplikat Kopie von Datenbank in den Cache-Speicher zu machen. Während Transaktionen mit einer Datenbank, erstellt der JPA zunächst eine doppelte Reihe von Daten und nur, wenn es sich verpflichtet, mit einem Unternehmen Manager, werden die Änderungen in die Datenbank erfolgt.

Es gibt zwei Möglichkeiten zum Abrufen von Datensätzen aus der Datenbank.

Eager Holen

In eifrig Abholen, verwandte Kind Objekte werden automatisch beim Abrufen einer bestimmten Datensatz hochgeladen.

Faule Holen

In faul Abruf, verwandte Objekte werden nicht automatisch hochgeladen, wenn Sie ausdrücklich darum bitten, für sie. Zunächst prüft es die Verfügbarkeit der Objekte verknüpft und benachrichtigt. Später, wenn Sie eines der Getter-Methode dieser Einheit rufen, dann holt er alle Rekorde.

Faule holen ist möglich, wenn Sie versuchen, die Datensätze für die erste Zeit zu holen. Auf diese Weise wird eine Kopie des gesamten Datensatz bereits in dem Cache-Speicher gespeichert. Performance-weise, faul zu holen ist vorzuziehen.