Consultas Criteria básicas

Introducción

Las consultas Criteria en Hibernate son una técnica de programación para la construcción de consultas a bases de datos de manera programática y con seguridad de tipos. Estas consultas son particularmente útiles cuando se necesita construir consultas dinámicas en las que los criterios de búsqueda pueden variar en tiempo de ejecución. Utilizando el API Criteria, los desarrolladores pueden armar consultas de base de datos sin escribir sentencias SQL explícitas, lo que ayuda a evitar errores comunes como las inyecciones SQL.

Uso básico del API Criteria

El API Criteria de Hibernate permite construir consultas de una forma muy estructurada y clara. El primer paso es obtener una instancia de CriteriaBuilder, que es la fábrica para todos los componentes de la consulta, como predicados y ordenaciones.

Creación de un CriteriaQuery

Para crear una consulta básica, se inicia con CriteriaBuilder y luego se define el tipo de entidad que será retornada por la consulta. Se asume que ya se tiene una sesión de Hibernate abierta a través de un SessionFactory (Session session = sessionFactory.openSession();).

// Obtener el CriteriaBuilder
CriteriaBuilder cb = session.getCriteriaBuilder();

// Crear un CriteriaQuery
CriteriaQuery<Empleado> cr = cb.createQuery(Empleado.class);

Definición del root

El root especifica el origen de las entidades en la consulta, equivalente a la cláusula FROM en SQL:

// Definición del root para la entidad Empleado
Root<Empleado> root = cr.from(Empleado.class);

Selección de la consulta

Se especifica qué se quiere seleccionar o retornar en la consulta, en este caso, se seleccionan todos los atributos de la entidad Empleado:

// Seleccionar el root (equivalente a SELECT *)
cr.select(root);

Métodos en Criteria API

select(Root<T> root): Especifica qué entidad o atributo se quiere seleccionar en el resultado de la consulta. Equivale a la cláusula SELECT en SQL.

from(Class<T> entityClass): Establece la entidad principal sobre la que se realizará la consulta, determinando así la tabla de la base de datos involucrada. Funciona como la cláusula FROM en SQL.

where(Expression<Boolean> restriction): Añade condiciones a la consulta, las cuales deben ser cumplidas por los elementos para ser retornados. Corresponde a la cláusula WHERE en SQL.

equal(Expression<?> x, Object y): Crea un predicado que compara por igualdad entre un atributo de la entidad y un valor específico.

Otros predicados: Aparte de equal, existen muchos otros predicados que pueden usarse en una consulta where, como: notEqual (!=), greaterThan (>), lessThan (<), between, isNull, isNotNull, like, in, and, or, not.

groupBy(Expression<?>… grouping): Agrupa los resultados según las expresiones especificadas, normalmente utilizadas en consultas que utilizan funciones de agregación. Similar a la cláusula GROUP BY en SQL.

having(Expression<Boolean> restriction): Especifica una condición para los grupos definidos por groupBy. Actúa como la cláusula HAVING en SQL, usada para condiciones en funciones de agregación.

Ejemplo: Consulta de empleados por nombre

Supongamos que queremos obtener todos los empleados cuyo nombre sea “Juan”. Utilizaríamos el Criteria API de la siguiente manera:

// Configuración del CriteriaBuilder y del CriteriaQuery
CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<Empleado> cr = cb.createQuery(Empleado.class);
Root<Empleado> root = cr.from(Empleado.class);

// Construcción del predicado para la consulta
Predicate nombrePredicado = cb.equal(root.get("nombre"), "Juan");

// Establecimiento del predicado como la cláusula WHERE de la consulta
cr.select(root).where(nombrePredicado);

// Ejecución de la consulta
List<Empleado> resultado = session.createQuery(cr).getResultList();

// Manejo del resultado
resultado.forEach(emp -> System.out.println(emp.getNombre()));

Otros aspectos básicos de Criteria API

Uso de Restrictions

Las Restrictions en el Criteria API permiten agregar condiciones específicas a las consultas, como igualdades, desigualdades y otras comparaciones básicas. El uso de equal en el apartado anterior es un ejemplo de esto. Estas condiciones se aplican en la cláusula WHERE de la consulta SQL generada por Hibernate.

// Creación de condiciones de restricción
Predicate condicionIgualdad = cb.equal(root.get("edad"), 30);
Predicate condicionDesigualdad = cb.notEqual(root.get("nombre"), "Pedro");
Predicate condicionMayorQue = cb.greaterThan(root.get("salario"), 50000);

// Aplicación de múltiples condiciones
cr.select(root).where(cb.and(condicionIgualdad, condicionDesigualdad, condicionMayorQue));

Uso de proyecciones y agregaciones

Las proyecciones y agregaciones se manejan en Criteria API mediante el uso de Projections, y se utilizan para especificar qué campos o atributos específicos de las entidades se deben recuperar. Una proyección puede ser tan simple como seleccionar un campo específico de una entidad o tan compleja como realizar cálculos o funciones agregadas sobre esos campos. Esto permite realizar operaciones como contar, sumar, promediar, entre otras, directamente en la consulta.

// Crear proyecciones para operaciones de agregación
CriteriaQuery<Long> crCount = cb.createQuery(Long.class);
crCount.select(cb.count(root));

// Ejemplo de proyección para sumar salarios
CriteriaQuery<Double> crSum = cb.createQuery(Double.class);
crSum.select(cb.sum(root.get("salario")));

// Obtener resultados de agregación
Long totalEmpleados = session.createQuery(crCount).getSingleResult();
Double sumaSalarios = session.createQuery(crSum).getSingleResult();

Ordenación de resultados

La ordenación de resultados se realiza mediante el objeto Order, que especifica el criterio de ordenación ascendente o descendente para uno o más atributos.

// Ordenar resultados por nombre de manera ascendente
Order ordenAscendente = cb.asc(root.get("nombre"));
cr.orderBy(ordenAscendente);

// Ejemplo de orden descendente por salario
Order ordenDescendente = cb.desc(root.get("salario"));
cr.orderBy(ordenDescendente);

Paging de resultados

El paging de resultados, o paginación, se implementa en Criteria API mediante los métodos setFirstResult y setMaxResults, que definen el inicio de la consulta y la cantidad máxima de resultados a retornar.

// Configuración de paginación para obtener la primera página de 10 elementos
cr.setFirstResult(0); // índice del primer resultado
cr.setMaxResults(10); // cantidad máxima de resultados

// Ejecución de consulta con paginación
List<Empleado> empleadosPagina1 = session.createQuery(cr).getResultList();

Ventajas del uso de Criteria API

1. Seguridad de tipos: Al usar el Criteria API, muchos errores pueden ser detectados en tiempo de compilación.
2. Consulta dinámica: Es fácil modificar componentes de la consulta en tiempo de ejecución, lo que es útil para consultas dinámicas basadas en la entrada del usuario.
3. Independencia del dialecto SQL: Hibernate maneja la traducción a SQL, lo cual permite que el código sea independiente del motor de base de datos.

Las consultas Criteria ofrecen una forma robusta y flexible de interactuar con bases de datos en aplicaciones Java, especialmente útil en aplicaciones de gran escala donde las consultas pueden ser muy variadas y dependientes de condiciones de tiempo de ejecución.