Uso del Constructor de Condiciones QueryWrapper

El componente QueryWrapper hereda de AbstractWrapper. Su propiedad interna entity también se utiliza para generar las cláusulas WHERE de las consultas. Para obtener un wrapper basado en Lambda, se puede emplear el método new QueryWrapper().lambda().

Tabla de ejemplo utilizada en las pruebas.

1. Métodos eq y ne

Descripción: eq significa igualdad (=), mientras que ne significa desigualdad (!=).

Ejemplo práctico:

@Test
public void probarIgualdad(){
        QueryWrapper<Producto> envoltorio = new QueryWrapper<>();
        //eq() - Igual a
        envoltorio.eq("nombre", "Pistón Hidráulico");
        Producto articulo = productoServicio.obtenerUno(envoltorio);
        System.out.println(articulo);
}

@Test
public void probarDesigualdad(){
        QueryWrapper<Producto> envoltorio = new QueryWrapper<>();
        //ne() - No igual a
        envoltorio.ne("estado", 0);
        List<Producto> lista = productoServicio.listar(envoltorio);
        System.out.println(lista);
}

2. Métodos gt, ge, lt, le

Descripción: Son operadores de comparación numérica. gt (mayor que), ge (mayor o igual que), lt (menor que), le (menor o igual que).

Ejemplo práctico:

@Test
public void probarComparacionesNumericas(){
        QueryWrapper<Producto> wrapperMayor = new QueryWrapper<>();
        //gt() - Mayor que
        wrapperMayor.gt("precio", 150.00);
        List<Producto> listaMayor = productoServicio.listar(wrapperMayor);
        System.out.println("Productos con precio mayor a 150: " + listaMayor);

        //**********************

        QueryWrapper<Producto> wrapperMenorIgual = new QueryWrapper<>();
        //le() - Menor o igual que
        wrapperMenorIgual.le("stock", 50);
        List<Producto> listaMenorIgual = productoServicio.listar(wrapperMenorIgual);
        System.out.println("Productos con stock igual o menor a 50: " + listaMenorIgual);
}

3. Métodos between y notBetween

Descripción: between seleccciona valores dentro de un rango inclusivo (valor1 y valor2). notBetween selecciona valores fuera de ese rango.

Ejemplo práctico:

@Test
public void probarRangos(){
        QueryWrapper<Producto> wrapperEnRango = new QueryWrapper<>();
        //between() - Dentro del rango [10, 100]
        wrapperEnRango.between("stock", 10, 100);
        List<Producto> listaEnRango = productoServicio.listar(wrapperEnRango);
        System.out.println("Productos con stock entre 10 y 100: " + listaEnRango);

        //**********************

        QueryWrapper<Producto> wrapperFueraRango = new QueryWrapper<>();
        //notBetween() - Fuera del rango [10, 100]
        wrapperFueraRango.notBetween("stock", 10, 100);
        List<Producto> listaFueraRango = productoServicio.listar(wrapperFueraRango);
        System.out.println("Productos con stock fuera de [10,100]: " + listaFueraRango);
}

4. Métodos like, notLike, likeLeft, likeRight

Descripción: Realizan búsquedas difusas. like busca en cualquier posición (%valor%). notLike excluye ese patrón. likeLeft busca al final (%valor) y likeRight busca al inicio (valor%).

Ejemplo práctico:

@Test
public void probarBusquedasDifusas(){
        QueryWrapper<Producto> wrapperContiene = new QueryWrapper<>();
        //like() - Contiene el texto "acero"
        wrapperContiene.like("descripcion", "acero");
        List<Producto> listaContiene = productoServicio.listar(wrapperContiene);
        System.out.println("Productos que contienen 'acero': " + listaContiene);

        //**********************

        QueryWrapper<Producto> wrapperTermina = new QueryWrapper<>();
        //likeRight() - El nombre termina con "T"
        wrapperTermina.likeRight("nombre", "T");
        List<Producto> listaTermina = productoServicio.listar(wrapperTermina);
        System.out.println("Productos cuyo nombre termina en 'T': " + listaTermina);
}

5. Métodos isNull y isNotNull

Descripción: isNull verifica que un campo sea nulo (IS NULL). isNotNull verifica que no sea nulo (IS NOT NULL).

Ejemplo práctico:

@Test
public void probarNulos(){
        QueryWrapper<Producto> wrapperSinImagen = new QueryWrapper<>();
        //isNull() - El campo "url_imagen" es nulo
        wrapperSinImagen.isNull("url_imagen");
        List<Producto> listaSinImagen = productoServicio.listar(wrapperSinImagen);
        System.out.println("Productos sin imagen: " + listaSinImagen);

        //**********************

        QueryWrapper<Producto> wrapperConDescripcion = new QueryWrapper<>();
        //isNotNull() - El campo "descripcion" no es nulo
        wrapperConDescripcion.isNotNull("descripcion");
        List<Producto> listaConDescripcion = productoServicio.listar(wrapperConDescripcion);
        System.out.println("Productos con descripción: " + listaConDescripcion);
}

6. Métodos in y notIn

Descripción: in verifica que el valor del campo esté dentro de una lista de valores proporcionados (IN (v0, v1, ...)). notIn verifica que NO esté en esa lista.

Ejemplo práctico:

@Test
public void probarListasDeValores(){
        QueryWrapper<Producto> wrapperCategorias = new QueryWrapper<>();
        //in() - La categoría debe ser 1, 5 o 9
        wrapperCategorias.in("categoria_id", 1, 5, 9);
        List<Producto> listaCategorias = productoServicio.listar(wrapperCategorias);
        System.out.println("Productos en categorías 1, 5, 9: " + listaCategorias);

        //**********************

        QueryWrapper<Producto> wrapperExcluirIds = new QueryWrapper<>();
        //notIn() - Excluir productos con IDs 101, 205, 300
        wrapperExcluirIds.notIn("id", 101, 205, 300);
        List<Producto> listaExcluidos = productoServicio.listar(wrapperExcluirIds);
        System.out.println("Productos excluyendo IDs 101,205,300: " + listaExcluidos);
}

7. Métodos or y and

Descripción: Definen la lógica combinada de las condiciones. or() conecta la siguiente condición con un OR. Si no se llama explícitamente a or(), las condiciones se conectan por defeccto con AND.

Ejemplo práctico:

@Test
public void probarLogicaOR(){
        QueryWrapper<Producto> wrapperOr = new QueryWrapper<>();
        //or() - Buscar productos con precio > 200 O con stock < 10
        wrapperOr.gt("precio", 200.0).or().lt("stock", 10);
        List<Producto> listaOr = productoServicio.listar(wrapperOr);
        System.out.println("Productos con precio > 200 O stock < 10: " + listaOr);
}

@Test
public void probarLogicaANDImplicita(){
        QueryWrapper<Producto> wrapperAnd = new QueryWrapper<>();
        // Condiciones unidas por AND (comportamiento por defecto)
        // Buscar nombre "Engranaje Estándar" Y categoría 3
        wrapperAnd.eq("nombre", "Engranaje Estándar").eq("categoria_id", 3);
        List<Producto> listaAnd = productoServicio.listar(wrapperAnd);
        System.out.println("Producto 'Engranaje Estándar' en categoría 3: " + listaAnd);
}

8. Métodos orderByAsc y orderByDesc

Descripción: orderByAsc ordena los resultados de forma ascendente por el campo especifciado. orderByDesc ordena de forma descendente.

Ejemplo práctico:

@Test
public void probarOrdenamientos(){
        QueryWrapper<Producto> wrapperOrden = new QueryWrapper<>();
        //orderByAsc() - Ordenar por fecha de creación (ascendente)
        wrapperOrden.orderByAsc("fecha_creacion");
        List<Producto> listaOrdenadaAsc = productoServicio.listar(wrapperOrden);
        System.out.println("Productos ordenados por fecha (antiguo a nuevo):");
        listaOrdenadaAsc.forEach(System.out::println);

        //**********************

        QueryWrapper<Producto> wrapperOrdenDesc = new QueryWrapper<>();
        //orderByDesc() - Ordenar por precio (mayor a menor)
        wrapperOrdenDesc.orderByDesc("precio");
        List<Producto> listaOrdenadaDesc = productoServicio.listar(wrapperOrdenDesc);
        System.out.println("Productos ordenados por precio (mayor a menor):");
        listaOrdenadaDesc.forEach(System.out::println);
}

9. Métodos inSql y notInSql (Uso menos frecuente)

Descripción: Permiten definir la lista de valores mediante una subconsulta SQL directa. inSql equivale a IN (subconsulta), notInSql a NOT IN (subconsulta).

Ejemplo práctico:

@Test
public void probarSubconsultas(){
        QueryWrapper<Producto> wrapperSubConsulta = new QueryWrapper<>();
        //inSql() - Filtrar por IDs obtenidos de otra tabla
        String sqlSubConsulta = "SELECT producto_id FROM inventario WHERE cantidad > 100";
        wrapperSubConsulta.inSql("id", sqlSubConsulta);
        List<Producto> listaSubConsulta = productoServicio.listar(wrapperSubConsulta);
        System.out.println("Productos con alto inventario: " + listaSubConsulta);
}

10. Métodos exists y notExists (Uso menos frecuente)

Descripción: exists agrega la condición EXISTS (subconsulta) a la cláusula WHERE. notExists agrega NOT EXISTS (subconsulta). Son útiles para correlacionar con datos de otras tablas.

Ejemplo práctico:

@Test
public void probarExistencia(){
        QueryWrapper<Producto> wrapperExiste = new QueryWrapper<>();
        //exists() - Verificar si existe un registro relacionado en la tabla de pedidos
        String sqlExistencia = "SELECT 1 FROM pedido_detalle pd WHERE pd.producto_id = id";
        wrapperExiste.exists(sqlExistencia);
        List<Producto> listaExistente = productoServicio.listar(wrapperExiste);
        System.out.println("Productos que han sido pedidos: " + listaExistente);
}