JPA - JPQL

---

---

Este captulo describe sobre JPQL y cmo funciona con unidades de persistencia. En este captulo, los ejemplos dados sigan la misma jerarqua del paquete, que se utiliz en el captulo 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 clusula SELECT, puede hacer a granel actualizaciones con clusula UPDATE y DELETE clusula.

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 actualizacin 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 clculo de los valores de entrada.

Utilizaremos el mismo ejemplo de gestin de empleados como en el captulo anterior. Aqu nos dirigiremos a travs 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.tutorialspoint.eclipselink.service paquete de la siguiente manera.

package com.tutorialspoint.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);
   }
}

Despus de la compilacin y ejecucin 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

Entre, y, como palabras clave

Entre, Y, Y Como son las palabras clave principales de JPQL. Estas palabras clave se utilizan despus de Donde clusula en una consulta.

Crear una clase denominada BetweenAndLikeFunctions.java bajo com.tutorialspoint.eclipselink.servicepaquete de la siguiente manera:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.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( ));
      }
   }
}

Despus 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 clusula ORDER BY. El uso de esta clusula es igual que en SQL, pero se trata de entidades. El ejemplo siguiente muestra cmo utilizar la clusula ORDER BY.

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

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.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 anotacin @NamedQuery se define como una consulta con una cadena de consulta predefinida que es inmutable. En contraste con consultas dinmicas, llamadas consultas pueden mejorar la organizacin del cdigo al separar las cadenas de consulta JPQL de POJO. Tambin pasa los parmetros de consulta en lugar de incrustar los literales dinmicamente en la cadena de consulta y por lo tanto produce ms eficientes consultas.

En primer lugar, aadir anotacin @NamedQuery a la clase de entidad empleado llamada Employee.java bajo com.tutorialspoint.eclipselink.entity paquete de la siguiente manera:

package com.tutorialspoint.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.tutorialspoint.eclipselink.service paquete de la siguiente manera:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.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( ));
      }
   }
}

Despus 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

Despus de agregar todas las clases sobre la jerarqua del paquete Mira como sigue:

Ansiosos y perezoso a buscar

El concepto ms 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 slo 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 automticamente al ir a buscar un registro concreto.

Lazy fetch

En recuperar el perezoso, objetos relacionados no se cargan automticamente a menos que usted solicite especficamente para ellos. En primer lugar, comprueba la disponibilidad de objetos relacionados y notifica. Ms tarde, si se llama a cualquiera del mtodo 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.

---

---