Consultas JPQL básicas

Introducción

La Jakarta Persistence Query Language (JPQL) es un componente clave de Hibernate, que proporciona una manera de realizar consultas sobre entidades gestionadas por el contexto de persistencia de Hibernate, de forma similar a cómo se realiza en SQL pero operando directamente sobre entidades Java en lugar de tablas de bases de datos. 

JPQL permite seleccionar, filtrar y manipular datos de una forma que es independiente de la base de datos subyacente. Las consultas JPQL se escriben en términos de clases y propiedades de Java en lugar de tablas y columnas de bases de datos.

Consulta básica

En el ámbito de Hibernate y JPQL, una consulta básica es aquella que permite recuperar entidades completas o parte de ellas de la base de datos. Estas consultas sirven como punto de partida para operaciones más complejas. El comando SELECT de JPQL permite seleccionar entidades específicas basadas en criterios definidos o simplemente recuperar todas las instancias de una clase. La sintaxis básica involucra especificar qué se desea seleccionar (en este caso, entidades completas) y de dónde (la clase de entidad en cuestión).

Consideremos un escenario en el que deseamos seleccionar todos los registros de empleados en una aplicación de gestión empresarial. La clase Empleado representa la entidad en nuestro modelo de datos. La consulta JPQL para realizar esta operación sería:

// Crear una instancia de Query usando el método createQuery() del EntityManager
jakarta.persistence.Query query = entityManager.createQuery("SELECT e FROM Empleado e");

// Ejecutar la consulta y recuperar la lista de resultados
List<Empleado> resultado = query.getResultList();

• EntityManager: Este es el punto de partida para la interacción con la persistencia en una aplicación JPA. Provee métodos para crear y ejecutar consultas, además de gestionar el ciclo de vida de las entidades. En este caso, entityManager se utiliza para crear una nueva consulta JPQL.
• Consulta JPQL: "SELECT e FROM Empleado e" es la consulta JPQL propiamente dicha. Aquí, SELECT e indica que deseamos seleccionar entidades completas, representadas temporalmente por el alias e en el contexto de esta consulta. FROM Empleado e especifica la clase de entidad Empleado desde la cual se seleccionarán las instancias, nuevamente utilizando e como un alias para referenciar a cualquier instancia de Empleado dentro de la consulta.
• Ejecución de la consulta y recuperación de resultados: query.getResultList() ejecuta la consulta y recopila los resultados en una lista de Empleado.

Los alias como e en esta consulta cumplen múltiples propósitos. Primero, permiten referencias concisas a entidades en otras partes de la consulta, como condiciones de filtrado, ordenamiento, etc. Segundo, mejoran la legibilidad de la consulta, especialmente cuando se realizan operaciones más complejas como JOINs.

Filtrado de resultados

El filtrado de resultados permite obtener un conjunto de datos específico basado en criterios definidos. JPQL permite filtrar datos mediante el uso de la cláusula WHERE.

Consideremos un caso práctico en el que necesitamos seleccionar empleados de una base de datos cuyos salarios superen un valor mínimo determinado:

// Preparación de la consulta JPQL con un parámetro de filtro
jakarta.persistence.Query query = entityManager.createQuery("SELECT e FROM Empleado e WHERE e.salario > :salarioMinimo");

// Establecimiento del parámetro de la consulta
query.setParameter("salarioMinimo", 30000);

// Ejecución de la consulta y recuperación de los resultados
List<Empleado> resultado = query.getResultList();

• Creación de la consulta: Usamos EntityManager para crear una nueva consulta JPQL mediante createQuery(). La consulta "SELECT e FROM Empleado e WHERE e.salario > :salarioMinimo" especifica que queremos seleccionar entidades Empleado (e) cuyo atributo salario exceda un valor mínimo (:salarioMinimo).
• Uso de parámetros: La consulta utiliza un parámetro nombrado :salarioMinimo para representar el umbral salarial en el filtrado. El uso de parámetros no solo incrementa la seguridad evitando la inyección de SQL, sino que también hace el código más flexible y reutilizable.
• Establecimiento del parámetro: query.setParameter("salarioMinimo", 30000) asigna el valor 30000 al parámetro salarioMinimo en la consulta.
• Recuperación de resultados: query.getResultList() ejecuta la consulta filtrada y recopila los resultados en una lista de entidades Empleado.

Ordenar resultados

En JPQL, el ordenamiento de resultados se logra mediante la cláusula ORDER BY. Esta cláusula es especialmente útil cuando se necesita presentar los datos en secuencias específicas, ya sea ascendente (ASC) o descendente (DESC), basado en uno o varios atributos de las entidades.

Consideremos que necesitamos obtener una lista de empleados de una empresa, ordenada alfabéticamente por sus nombres:

// Preparación de la consulta JPQL con ordenamiento
jakarta.persistence.Query query = entityManager.createQuery("SELECT e FROM Empleado e ORDER BY e.nombre ASC");

// Ejecución de la consulta y recuperación de los resultados ordenados
List<Empleado> resultado = query.getResultList();

• Creación de la consulta con ordenamiento: La consulta JPQL "SELECT e FROM Empleado e ORDER BY e.nombre ASC" indica que deseamos seleccionar todas las entidades Empleado (e), ordenadas por el atributo nombre de manera ascendente.
• Especificación del orden: La cláusula ORDER BY e.nombre ASC especifica el criterio de ordenamiento. En este caso, e.nombre refiere al atributo nombre de la entidad Empleado, y ASC indica que el ordenamiento debe ser ascendente. Si se deseara un ordenamiento descendente, se utilizaría DESC en lugar de ASC.
• Recuperación y ordenamiento de resultados: query.getResultList() ejecuta la consulta, y el sistema de gestión de bases de datos ordena los registros de acuerdo con el criterio especificado antes de retornarlos.

Consulta de campos específicos

La consulta de campos específicos en JPQL permite seleccionar y recuperar únicamente los atributos necesarios de las entidades, en lugar de cargar la entidad completa. Esta capacidad de seleccionar campos individuales directamente en la consulta ayuda a optimizar el uso de la memoria y puede mejorar la velocidad de ejecución de las aplicaciones.

Imaginemos un escenario donde necesitamos generar un reporte de los empleados que ganan más de un salario mínimo específico, pero solo estamos interesados en sus nombres y salarios, y no en la totalidad de la información de la entidad Empleado. A continuación se muestra cómo se puede realizar esta operación usando JPQL:

// Preparar una consulta JPQL para seleccionar campos específicos
jakarta.persistence.Query query = entityManager.createQuery("SELECT e.nombre, e.salario FROM Empleado e WHERE e.salario > :salarioMinimo");

// Establecer el parámetro de la consulta para el filtrado por salario
query.setParameter("salarioMinimo", 30000);

// Ejecutar la consulta y recuperar los resultados
List<Object[]> resultado = query.getResultList();

// Iterar sobre los resultados para acceder a los campos seleccionados
for (Object[] empleado : resultado) {
    System.out.println("Nombre: " + empleado[0] + ", Salario: " + empleado[1]);
}

• Creación de la consulta: La consulta "SELECT e.nombre, e.salario FROM Empleado e WHERE e.salario > :salarioMinimo" indica que deseamos seleccionar solo los atributos nombre y salario de las entidades Empleado que cumplan con la condición especificada en la cláusula WHERE.
• Ejecución de la consulta y recuperación de resultados: query.getResultList() ejecuta la consulta, devolviendo una lista de arrays de objetos (Object[]), donde cada array representa un conjunto de campos (en este caso, nombre y salario) de un empleado que cumple con la condición especificada.
• Acceso a los campos seleccionados: Iteramos sobre la lista de resultados, accediendo a cada campo por su índice dentro del array. Este paso es necesario porque, al seleccionar campos específicos en lugar de entidades completas, los resultados no se devuelven como objetos de tipo Empleado, sino como arrays de Object.