JPA - JPQL

Este capítulo describe sobre JPQL y cómo funciona con unidades de persistencia. En este capítulo, los ejemplos dados sigan la misma jerarquía del paquete, que se utilizó en el capítulo anterior.

Lenguaje de consulta de persistencia de Java

JPQL está parado para el lenguaje de consulta de persistencia de Java. Se utiliza para crear consultas contra entidades para almacenar en una base de datos relacional. JPQL está desarrollado en base a la sintaxis SQL. Pero no afectará directamente a la base de datos.

JPQL puede recuperar datos mediante la cláusula SELECT, puede hacer a granel actualizaciones con cláusula UPDATE y DELETE cláusula.

Estructura de consulta

Sintaxis JPQL es muy similar a la sintaxis de SQL. Tener SQL como sintaxis es una ventaja porque SQL es simple y siendo ampliamente utilizado. SQL trabaja directamente contra la base de datos relacional tablas, registros y campos, mientras que JPQL trabaja con Java clases e instancias.

Por ejemplo, una consulta JPQL puede recuperar una entidad objeto en lugar de campo conjunto de resultados de una base de datos, al igual que con SQL. El JPQL consulta estructura como sigue.

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

La estructura de JPQL borrar y consultas de actualización son las siguientes.

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

Funciones escalares y agregadas

Las funciones escalares devuelven valores resultantes basados en los valores de entrada. Funciones de agregado de devuelvan los valores resultantes mediante el cálculo de los valores de entrada.

Utilizaremos el mismo ejemplo de gestión de empleados como en el capítulo anterior. Aquí nos dirigiremos a través de las clases de servicio utilizando funciones escalares y agregadas de JPQL.

Nos dejaron asumen que la tabla jpadb.employee contiene los siguientes registros.

Crear una clase denominada ScalarandAggregateFunctions.java bajo com.howcodex.eclipselink.service paquete de la siguiente manera.

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);
   }
}

Después de la compilación y ejecución del programa anterior obtendrá la siguiente salida en el panel de consola del IDE de Eclipse.

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

Between, And, Like palabras clave

Between (Entre), And (Y), y Like (Como) son las palabras clave principales de JPQL. Estas palabras clave se utilizan después de Donde cláusula en una consulta.

Crear una clase denominada BetweenAndLikeFunctions.java bajo com.howcodex.eclipselink.service paquete de la siguiente manera:

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( ));
      }
   }
}

Después de compilar y ejecutar el programa anterior, obtendrá la siguiente salida en el panel de la consola de Eclipse IDE.

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

Ordenar

Para ordenar los registros en JPQL, utilizamos la cláusula ORDER BY. El uso de esta cláusula es igual que en SQL, pero se trata de entidades. El ejemplo siguiente muestra cómo utilizar la cláusula ORDER BY.

Crear una clase Ordering.java bajo com.howcodex.eclipselink.service paquete de la siguiente manera:

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( ));
      }
   }
}

compilar y ejecutar el programa anterior producirá la siguiente salida en el panel de la consola de Eclipse IDE.

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

Llamado consultas

Una anotación @NamedQuery se define como una consulta con una cadena de consulta predefinida que es inmutable. En contraste con consultas dinámicas, llamadas consultas pueden mejorar la organización del código al separar las cadenas de consulta JPQL de POJO. También pasa los parámetros de consulta en lugar de incrustar los literales dinámicamente en la cadena de consulta y por lo tanto produce más eficientes consultas.

En primer lugar, añadir anotación @NamedQuery a la clase de entidad empleado llamada Employee.java bajo com.howcodex.eclipselink.entity paquete de la siguiente manera:

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 + "]";
   }
}

Crear una clase denominada NamedQueries.java bajo com.howcodex.eclipselink.service paquete de la siguiente manera:

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( ));
      }
   }
}

Después de compilar y ejecutar el programa anterior obtendrá la siguiente salida en el panel de la consola de Eclipse IDE.

Employee ID :1204	 Employee Name :Satish

Después de agregar todas las clases sobre la jerarquía del paquete Mira como sigue:

Ansiosos y perezoso a buscar

El concepto más importante de JPA es hacer una copia duplicada de la base de datos en la memoria caché. Mientras se tramita con una base de datos, la JPA primero crea un duplicado de los datos y sólo cuando se ha comprometido con una entidad Director, los cambios se realizan en la base de datos.

Allí es dos maneras de obtener los registros de la base de datos.

Fetch ansioso

En buscar ansiosos, relacionados con objetos secundarios se cargan automáticamente al ir a buscar un registro concreto.

Lazy fetch

En recuperar el perezoso, objetos relacionados no se cargan automáticamente a menos que usted solicite específicamente para ellos. En primer lugar, comprueba la disponibilidad de objetos relacionados y notifica. Más tarde, si se llama a cualquiera del método getter de esa entidad, luego recupera todos los registros.

Fetch perezoso es posible cuando se intenta buscar los registros por primera vez. De esa manera, una copia del registro todo ya está almacenada en la memoria caché. Rendimiento, es preferible fetch perezoso.