JPA - JPQL

Este capítulo descreve a JPQL e como ela trabalha com unidades de persistência. Neste capítulo, os exemplos se seguem a mesma hierarquia de pacotes, que foi utilizado no capítulo anterior.

JPA JPQL

Java Persistence Query language

JPQL significa Java Persistence Query Language. Ele é usado para criar consultas contra entidades para armazenar em um banco de dados relacional. JPQL é desenvolvido com base na sintaxe SQL. Mas isso não vai afetar o banco de dados diretamente.

JPQL pode recuperar dados utilizando cláusula SELECT, pode fazer atualizações em lote usando o UPDATE e DELETE cláusula cláusula.

Estrutura de Consulta

Sintaxe JPQL é muito semelhante à sintaxe do SQL. Tendo SQL sintaxe como é uma vantagem porque O SQL é simples e está sendo amplamente utilizado. SQL trabalha diretamente contra tabelas de banco de dados relacional, registros e campos, considerando que JPQL trabalha com Java classes e instâncias.

Por exemplo, a JPQL consulta pode recuperar uma entidade objeto em vez de campo resultado definido a partir de um banco de dados, como com o SQL. A JPQL estrutura de consulta como se segue.

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

A estrutura de JPQL EXCLUIR e atualizar as consultas são como segue.

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

Escalar e funções de agregação

Scalar funções retornam valores resultantes com base em valores de entrada. Funções de agregação voltar os valores resultantes do cálculo dos valores de entrada.

Vamos usar o mesmo exemplo empregado Gerenciamento como no capítulo anterior. Aqui, vamos passar as classes de serviço usando escalar e funções de agregação de JPQL.

Consideremos o jpadb.trabalhador tabela contém os seguintes registros.

Eid Ename Salário Deg
1201 Gopal 40000 Gestor Técnico
1202 Manisha 40000 Leitor Prova
1203 Masthanvali 40000 Redator técnico
1204 Satish 30000 Redator técnico
1205 Krishna 30000 Redator técnico
1206 Kiran 35000 Leitor Prova

Criar uma classe chamada ScalarandAggregateFunctions.java sobcom.tutorialspoint.eclipselink.servicepacote de serviços como segue.

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

Após compilação e execução do referido programa, você irá obter o seguinte resultado no painel do console do Eclipse IDE.

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

Entre e, como palavras-chave

Entre, e e como são as principais palavras-chave de JPQL. Essas palavras-chave são utilizadas após cláusula Where em uma consulta.

Criar uma classe chamada BetweenAndLikeFunctions.javasob com.tutorialspoint.eclipselink.servicepacote de serviços como segue:

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

Após a compilação e execução do referido programa, você irá obter o seguinte resultado no painel do console do 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

Encomendar

Para solicitar os registros em JPQL, usamos a cláusula ORDER BY. O uso da presente cláusula é mesmo como no SQL, mas trata com as entidades. O exemplo a seguir mostra como usar a cláusula ORDER BY.

Crie uma classe java sob encomenda.com.tutorialspoint.eclipselink.servicepacote de serviços como segue:

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

Compilando e executando o programa acima referido irá produzir a seguinte saída no painel do console do 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

Consultas Nomeadas

A @NamedQuery anotação é definida como uma pré consulta com uma string de consulta que é imutável. Ao contrário de consultas dinâmicas consultas nomeadas pode melhorar o código organização, separando a JPQL seqüências de caracteres de consulta de EM POJO. Ela também passa a parâmetros de consulta em vez de incorporar o literais dinamicamente na string de consulta e, portanto, produz mais eficientes as consultas.

Primeiro de tudo, adicionar @NamedQuery anotação para o empregado entidade classe chamada empregado. java sobcom.tutorialspoint.eclipselink.entitypacote como segue:

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

Criar uma classe chamada NamedQueries.java sobcom.tutorialspoint.eclipselink.servicepacote de serviços como segue:

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

Após a compilação e execução do referido programa, você irá obter o seguinte resultado no painel do console do Eclipse IDE.

Employee ID :1204	 Employee Name :Satish

Depois de adicionar todas as classes acima da hierarquia de pacotes tem o seguinte aspecto:

Package Hierarchy

Ansioso e preguiçoso ao Buscar

O conceito mais importante da JPA é de fazer uma cópia do banco de dados em memória cache. Ao mesmo tempo que fazem transações com o banco de dados, a JPA em primeiro lugar cria um conjunto duplicado de dados e somente quando é cometido por meio de um gerenciador de entidades, as alterações são realizadas no banco de dados.

Há duas maneiras de buscar os registros do banco de dados.

Ansiosos por buscar

Na ansiosa busca, relacionados com crianças os objetos são carregados automaticamente ao buscar um determinado registro.

Lazy buscar

A lazy buscar, objetos relacionados não são carregados automaticamente, a menos que você especificamente pedido para eles. Primeiro de tudo, ele verifica a disponibilidade de objetos relacionados e o avisa. Mais tarde, se você chamar qualquer método getter da entidade que, em seguida, ela obtém todos os registros.

Lazy buscar é possível quando você tentar buscar os registros da primeira vez. Dessa forma, uma cópia de todo o registro já está armazenado na memória cache. Desempenho-sábio, lazy buscar é preferível.

Advertisements