Especifica un query

Datos de muestra

Los ejemplos de esta guía utilizan la entidad Movie, que representa la colección sample_mflix.movies del conjuntos de datos de muestras de Atlas. La entidad Movie tiene la siguiente definición:

import com.mongodb.hibernate.annotations.ObjectIdGenerator;
import org.bson.types.ObjectId;
import java.time.Instant;
import java.util.List;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
@Entity
@Table(name = "movies")
public class Movie {
   @Id
   @ObjectIdGenerator
   private ObjectId id;
   private String title;
   private String plot;
   private int year;
   private List<String> cast;
   private List<String> directors;
   private Instant released;
   @Embedded
   private Awards awards;
   @OneToMany(mappedBy = "movie", fetch = FetchType.LAZY)
   private List<Comment> comments;
   public Movie(String title, String plot, int year, List<String> cast, List<String> directors, Instant released, Awards awards) {
      this.title = title;
      this.plot = plot;
      this.year = year;
      this.cast = cast;
      this.directors = directors;
      this.released = released;
      this.awards = awards;
   }
   public Movie() {
   }
   public ObjectId getId() {
      return id;
   }
   public String getTitle() {
      return title;
   }
   public void setTitle(String title) {
      this.title = title;
   }
   public String getPlot() {
      return plot;
   }
   public void setPlot(String plot) {
      this.plot = plot;
   }
   public int getYear() {
      return year;
   }
   public void setYear(int year) {
      this.year = year;
   }
   public List<String> getCast() {
      return cast;
   }
   public void setCast(List<String> cast) {
      this.cast = cast;
   }
   public List<String> getDirectors() {
      return directors;
   }
   public void setDirectors(List<String> directors) {
      this.directors = directors;
   }
   public Awards getAwards() {
      return awards;
   }
   public void setAwards(Awards awards) {
      this.awards = awards;
   }
   public Instant getReleased() {
      return released;
   }
   public void setReleased(Instant released) {
      this.released = released;
   }
   public List<Comment> getComments() {
      return comments;
   }
   public void setComments(List<Comment> comments) {
      this.comments = comments;
   }
}

Para aprender a crear una aplicación Java que utilice la extensión MongoDB para Hibernate ORM para interactuar con esta colección de muestra de MongoDB, consulta el tutorial Primeros pasos.

Los ejemplos de código de esta página también utilizan el siguiente agregado incrustable Awards @Struct:

@Embeddable
@Struct(name = "Awards")
public class Awards {
    private int wins;
    private int nominations;
    private String text;
    public Awards(int wins, int nominations, String text) {
        this.wins = wins;
        this.nominations = nominations;
        this.text = text;
    }
    public Awards() {
    }
    public int getWins() {
        return wins;
    }
    public void setWins(int wins) {
        this.wins = wins;
    }
    public int getNominations() {
        return nominations;
    }
    public void setNominations(int nominations) {
        this.nominations = nominations;
    }
    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }
}

var sf = HibernateUtil.getSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
// ... Perform CRUD operations here
tx.commit();
session.close();
sf.close();

 // Replace <persistence unit> with the name of your persistence unit in the persistence.xml file
 EntityManagerFactory emf = Persistence.createEntityManagerFactory("<persistence unit>");
 EntityManager entityManager = entityManagerFactory.createEntityManager();
 entityManager.getTransaction().begin();
 // ... Perform CRUD operations here
entityManager.getTransaction().commit();
entityManager.close();
emf.close;

Comparar varios campos a la vez

Un predicado de valor de fila compara una lista de campos entre paréntesis con una lista de valores entre paréntesis en una sola expresión. La extensión Hibernate ORM admite predicados de valor de fila que utilizan los siguientes operadores:

• =: Coincidencia de igualdad

• <>Coincidencia de desigualdades

• IN y NOT IN: Comparación con una lista de filas de valores

Puede proporcionar los valores como parámetros vinculados o como literales, y cada lista debe contener el mismo número de componentes.

El siguiente ejemplo recupera documentos que tienen un valor title igual a "Jurassic World" y un valor year igual a 2015 de la colección sample_mflix.movies:

var rowValueResult = session.createQuery("from Movie where (title, year) = (:t, :y)", Movie.class)
                            .setParameter("t", "Jurassic World")
                            .setParameter("y", 2015)
                            .getResultList();
for (var m : rowValueResult) {
    System.out.println("Title: " + m.getTitle());
}

Title: Jurassic World

var rowValueResult = entityManager.createQuery("select m from Movie m where (m.title, m.year) = (:t, :y)", Movie.class)
                                  .setParameter("t", "Jurassic World")
                                  .setParameter("y", 2015)
                                  .getResultList();
for (var m : rowValueResult) {
    System.out.println("Title: " + m.getTitle());
}

Title: Jurassic World

La extensión Hibernate ORM compara cada par de componentes por separado. El predicado de valor de fila anterior se traduce en la siguiente etapa $match:

{
  "$match": {
    "$and": [
      { "title": { "$eq": "Jurassic World" } },
      { "year": { "$eq": 2015 } }
    ]
  }
}

Un predicado de valor de fila que utiliza el operador <> se traduce en la misma expresión $and envuelta en una expresión $nor.

Si comparas los campos con otra lista de campos, como en where (title1, year1) = (title2, year2), la extensión ORM de Hibernate traduce el predicado a una expresión $expr en su lugar.

Puedes usar un predicado de valor de fila en una cláusula SELECT. El predicado se evalúa como un valor booleano en la proyección.

var rowValueInResult = session.createQuery(
                "from Movie where (title, year) in (('Jurassic World', 2015), ('Ex Machina', 2015))", Movie.class)
        .getResultList();
for (var m : rowValueInResult) {
    System.out.println("Title: " + m.getTitle());
}

Title: Jurassic World
Title: Ex Machina

var rowValueInResult = entityManager.createQuery(
                "select m from Movie m where (m.title, m.year) in (('Jurassic World', 2015), ('Ex Machina', 2015))", Movie.class)
        .getResultList();
for (var m : rowValueInResult) {
    System.out.println("Title: " + m.getTitle());
}

Title: Jurassic World
Title: Ex Machina

{
  "$match": {
    "$or": [
      { "$and": [
          { "title": { "$eq": "Jurassic World" } },
          { "year": { "$eq": 2015 } }
      ] },
      { "$and": [
          { "title": { "$eq": "Ex Machina" } },
          { "year": { "$eq": 2015 } }
      ] }
    ]
  }
}

Comparar los valores de los campos con valores nulos.

Cuando se compara un campo con null mediante un operador de comparación, la extensión Hibernate ORM aplica la semántica nula del lenguaje de consulta de MongoDB en lugar de la lógica ternaria que define Hibernate ORM.

Los operadores de comparación de MongoDB evalúan tanto un campo faltante como un campo que almacena un valor null explícito con respecto a null. Como resultado, una comparación = null coincide con documentos en los que el campo almacena null y documentos en los que el campo está ausente. Una comparación <> null o != null coincide con documentos en los que el campo almacena cualquier otro valor.

El siguiente ejemplo utiliza el operador = para recuperar documentos que tienen un valor null o un valor cast faltante de la colección sample_mflix.movies:

var nullComparisonResult = session.createQuery("from Movie where cast = null", Movie.class)
        .getResultList();
for (var m : nullComparisonResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Song of Lahore
Title: A Sinner in Mecca
Title: Very Semi-Serious

var nullComparisonResult = entityManager.createQuery("select m from Movie m where m.cast = null", Movie.class)
        .getResultList();
for (var m : nullComparisonResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Song of Lahore
Title: A Sinner in Mecca
Title: Very Semi-Serious

La extensión Hibernate ORM traduce esta consulta a la siguiente etapa $match:

{
  "$match": {
    "cast": { "$eq": null }
  }
}

Las comparaciones que utilizan los operadores >, >=, < y <= siguen el orden de comparación BSON de MongoDB para campos inexistentes. Dado que null es un tipo BSON propio, una comparación >= null o <= null coincide con documentos en los que el campo almacena null o está ausente. Una comparación > null o < null no coincide con ningún documento.

Para hacer coincidir null con valores faltantes usando un predicado en lugar de un operador de comparación, consulte las secciones IS NULL e IS NOT NULL de esta guía.

Realizar operaciones aritméticas en una proyección

Al seleccionar una expresión calculada, la extensión Hibernate ORM agrega el valor calculado a la etapa $project. Si se le asigna un alias a la expresión mediante la palabra clave AS, la extensión Hibernate ORM utiliza dicho alias como clave de proyección. De lo contrario, genera una clave con el formato #c_<n>.

El siguiente ejemplo calcula la edad de cada película "Hairspray" en la colección sample_mflix.movies restando el valor del campo year de un parámetro de consulta:

var arithmeticResult = session.createQuery(
                "select title, :currentYear - year as age from Movie where title = :title",
                Object[].class)
        .setParameter("currentYear", 2026)
        .setParameter("title", "Hairspray")
        .getResultList();
for (var row : arithmeticResult) {
    System.out.println("Title: " + row[0] + ", Age: " + row[1]);
}

Title: Hairspray, Age: 38
Title: Hairspray, Age: 19

var arithmeticResult = entityManager.createQuery(
                "select m.title, :currentYear - m.year as age from Movie m where m.title = :title",
                Object[].class)
        .setParameter("currentYear", 2026)
        .setParameter("title", "Hairspray")
        .getResultList();
for (var row : arithmeticResult) {
    System.out.println("Title: " + row[0] + ", Age: " + row[1]);
}

Title: Hairspray, Age: 38
Title: Hairspray, Age: 19

La extensión Hibernate ORM traduce la expresión calculada anterior a la siguiente etapa $project:

{
  "$project": {
    "title": true,
    "age": { "$subtract": [ 2026, "$year" ] },
    "_id": 0
  }
}

Filtrar en una expresión calculada

En la cláusula WHERE, puede comparar una expresión calculada con un valor o comparar dos valores de campo entre sí. Cuando ninguno de los lados de la comparación es una referencia directa a un campo o valor, la extensión Hibernate ORM envuelve la comparación en el operador $expr de MongoDB. Las comparaciones entre un campo y un valor siguen utilizando la forma compacta { field: { operator: value } }.

El siguiente ejemplo recupera "Hairspray" películas estrenadas menos de 20 años antes de 2026:

var computedFilterResult = session.createQuery(
                "from Movie where title = :title and :currentYear - year < 20", Movie.class)
        .setParameter("title", "Hairspray")
        .setParameter("currentYear", 2026)
        .getResultList();
for (var m : computedFilterResult) {
    System.out.println("Title: " + m.getTitle() + ", Year: " + m.getYear());
}

Title: Hairspray, Year: 2007

var computedFilterResult = entityManager.createQuery(
                "select m from Movie m where m.title = :title and :currentYear - m.year < 20",
                Movie.class)
        .setParameter("title", "Hairspray")
        .setParameter("currentYear", 2026)
        .getResultList();
for (var m : computedFilterResult) {
    System.out.println("Title: " + m.getTitle() + ", Year: " + m.getYear());
}

Title: Hairspray, Year: 2007

La extensión Hibernate ORM traduce la consulta anterior a la siguiente etapa $match, en la que la comparación title utiliza la forma compacta y la comparación calculada utiliza $expr:

{
  "$match": {
    "$and": [
      { "title": { "$eq": "Hairspray" } },
      { "$expr": { "$lt": [ { "$subtract": [ 2026, "$year" ] }, 20 ] } }
    ]
  }
}

Proyectar un resultado de comparación

Puedes usar una comparación en una instrucción SELECT para devolver su resultado booleano en lugar de usar la comparación como un filtro.

El siguiente ejemplo devuelve el título de cada película "Hairspray" y si la película se estrenó después de 2000:

var comparisonResult = session.createQuery(
                "select title, year > 2000 as isRecent from Movie where title = :title",
                Object[].class)
        .setParameter("title", "Hairspray")
        .getResultList();
for (var row : comparisonResult) {
    System.out.println("Title: " + row[0] + ", Recent: " + row[1]);
}

Title: Hairspray, Recent: false
Title: Hairspray, Recent: true

var comparisonResult = entityManager.createQuery(
                "select m.title, m.year > 2000 as isRecent from Movie m where m.title = :title",
                Object[].class)
        .setParameter("title", "Hairspray")
        .getResultList();
for (var row : comparisonResult) {
    System.out.println("Title: " + row[0] + ", Recent: " + row[1]);
}

Title: Hairspray, Recent: false
Title: Hairspray, Recent: true

La extensión Hibernate ORM traduce la comparación anterior a la siguiente etapa $project:

{
  "$project": {
    "title": true,
    "isRecent": { "$gt": [ "$year", 2000 ] },
    "_id": 0
  }
}

EXISTS

El predicado EXISTS coincide con los documentos que tienen un campo específico y devuelve solo un resultado para cada documento padre coincidente, independientemente de cuántos elementos de la matriz coincidan.

Para ver un ejemplo completo, consulte la sección "Consulta sobre elementos de una matriz incrustada" de esta guía.

ENTRE

El predicado BETWEEN coincide con los documentos que tienen un valor de campo dentro de un rango especificado.

El siguiente ejemplo utiliza el predicado BETWEEN para recuperar documentos que tienen un valor year entre 2012 y 2013, ambos inclusive, de la colección sample_mflix.movies:

var betweenResult = session.createQuery("from Movie where year between :start and :end", Movie.class)
                           .setParameter("start", 2012)
                           .setParameter("end", 2013)
                           .getResultList();
for (var m : betweenResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Absent Minded
Title: The Disappearance of Eleanor Rigby: Her
Title: Thread of Lies

var betweenResult = entityManager.createQuery("select m from Movie m where m.year between :start and :end", Movie.class)
                                 .setParameter("start", 2012)
                                 .setParameter("end", 2013)
                                 .getResultList();
for (var m : betweenResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Absent Minded
Title: The Disappearance of Eleanor Rigby: Her
Title: Thread of Lies

La extensión Hibernate ORM traduce el predicado BETWEEN anterior a la siguiente etapa $match:

{
  "$match": {
    "year": { "$gte": 2012, "$lte": 2013 }
  }
}

in

El predicado IN coincide con los documentos donde el valor de un campo es igual a cualquier valor de una lista específica. Puede proporcionar los valores de la lista como literales, parámetros con nombre o parámetros posicionales.

El siguiente ejemplo utiliza el predicado IN para recuperar documentos que tienen un valor year igual a 1994 o 1996 de la colección sample_mflix.movies:

var inResult = session.createQuery("from Movie where year in (:first, :second)", Movie.class)
                      .setParameter("first", 1994)
                      .setParameter("second", 1996)
                      .getResultList();
for (var m : inResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Kadhal Kottai
Title: Gotti
Title: It's Just a Ride

var inResult = entityManager.createQuery("select m from Movie m where m.year in (:first, :second)", Movie.class)
                            .setParameter("first", 1994)
                            .setParameter("second", 1996)
                            .getResultList();
for (var m : inResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Kadhal Kottai
Title: Gotti
Title: It's Just a Ride

La extensión Hibernate ORM traduce el predicado IN anterior a la siguiente etapa $match:

{
  "$match": {
    "year": { "$in": [ 1994, 1996 ] }
  }
}

Una lista vacía es válida, pero nunca coincide con ningún documento. Por ejemplo, year in () no coincide con ningún documento.

NO EN

El predicado NOT IN coincide con documentos en los que el valor de un campo no coincide con ningún valor de una lista específica. NOT IN acepta los mismos formatos de lista y tiene las mismas limitaciones que el predicado IN.

El siguiente ejemplo utiliza el predicado NOT IN para recuperar documentos que tienen un valor title distinto de "Romeo and Juliet" o "Best in Show" de la colección sample_mflix.movies. Dado que NOT IN excluye solo los valores enumerados, el ejemplo llama al método setMaxResults() para limitar el conjunto de resultados a diez documentos:

var notInResult = session.createQuery("from Movie where title not in (:first, :second)", Movie.class)
                         .setParameter("first", "Romeo and Juliet")
                         .setParameter("second", "Best in Show")
                         .setMaxResults(10)
                         .getResultList();
for (var m : notInResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: 'R Xmas
Title: 'Round Midnight
Title: 'Til Madness Do Us Part

var notInResult = entityManager.createQuery("select m from Movie m where m.title not in (:first, :second)", Movie.class)
                               .setParameter("first", "Romeo and Juliet")
                               .setParameter("second", "Best in Show")
                               .setMaxResults(10)
                               .getResultList();
for (var m : notInResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: 'R Xmas
Title: 'Round Midnight
Title: 'Til Madness Do Us Part

La extensión Hibernate ORM traduce el predicado NOT IN anterior a la siguiente etapa $match:

{
  "$match": {
    "title": { "$nin": [ "Romeo and Juliet", "Best in Show" ] }
  }
}

Debido a que $nin compara cada documento con una lista vacía de valores, title not in () compara todos los documentos.

ES NULO

El predicado IS NULL coincide con los documentos que tienen un campo específico con un valor nulo o faltante.

Para comparar un campo con null utilizando un operador de comparación en lugar de un predicado, consulte la sección Comparar valores de campo con Null de esta guía.

El siguiente ejemplo utiliza el predicado IS NULL para recuperar documentos que tienen un valor faltante o null cast de la colección sample_mflix.movies:

var isNullResult = session.createQuery("from Movie where cast is null", Movie.class)
        .getResultList();
for (var m : isNullResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Tom Swift and His Electric Rifle
Title: A Sinner in Mecca
Title: Very Semi-Serious

var isNullResult = entityManager.createQuery("select m from Movie m where m.cast is null", Movie.class)
        .getResultList();
for (var m : isNullResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Tom Swift and His Electric Rifle
Title: A Sinner in Mecca
Title: Very Semi-Serious

La extensión Hibernate ORM traduce el predicado IS NULL precedente a la siguiente etapa $match, que coincide con los documentos donde el campo es explícitamente null o falta:

{
  "$match": {
    "cast": { "$eq": null }
  }
}

NO ES NULO

El predicado IS NOT NULL coincide con los documentos que tienen un campo con un valor no nulo o no faltante.

El siguiente ejemplo utiliza el predicado IS NOT NULL para recuperar documentos que tienen un valor directors de la colección sample_mflix.movies:

var isNotNullResult = session.createQuery("from Movie where directors is not null", Movie.class)
        .getResultList();
for (var m : isNotNullResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Our Loved Ones
Title: No Home Movie
Title: Scenes of a Sexual Nature

var isNotNullResultEm = entityManager.createQuery("select m from Movie m where m.directors is not null", Movie.class)
        .getResultList();
for (var m : isNotNullResultEm) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Our Loved Ones
Title: No Home Movie
Title: Scenes of a Sexual Nature

La extensión Hibernate ORM traduce el predicado IS NOT NULL precedente a la siguiente etapa $match, que coincide con los documentos donde el campo existe y no es explícitamente null:

{
  "$match": {
    "directors": { "$ne": null }
  }
}

COMO

El predicado LIKE distingue entre mayúsculas y minúsculas y coincide con documentos donde el valor de un campo coincide con un patrón especificado. El patrón se compara con el valor completo del campo y puede utilizar los siguientes caracteres comodín:

• %: Coincide con cero o más caracteres.

• _: Coincide exactamente con un carácter.

Para que coincida con un prefijo, incluya % al final del patrón, y para que coincida con un sufijo, incluya % al principio del patrón.

El siguiente ejemplo utiliza el predicado LIKE para recuperar documentos que tienen un valor title que comienza con "W", seguido de cualquier carácter individual y luego "r", de la colección sample_mflix.movies:

var likeResult = session.createQuery("from Movie where title like 'W_r%'", Movie.class)
                        .getResultList();
for (var m : likeResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: War and Peace
Title: Warlock
Title: Warrendale
Title: WarGames
Title: Working Girl

var likeResultEm = entityManager.createQuery("select m from Movie m where m.title like 'W_r%'", Movie.class)
                                .getResultList();
for (var m : likeResultEm) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: War and Peace
Title: Warlock
Title: Warrendale
Title: WarGames
Title: Working Girl

La extensión Hibernate ORM traduce el predicado LIKE anterior a la siguiente etapa $match:

{
  "$match": {
    "title": { "$regex": /^W.r.*$/s }
  }
}

Para obtener más información sobre el predicado HQL LIKE, consulte la Guía del lenguaje de consulta de Hibernate en la documentación de Hibernate ORM.

NO ES COMO

El predicado NOT LIKE coincide con los documentos en los que el valor de un campo no coincide con el patrón especificado. La extensión Hibernate ORM niega el filtro $regex que produce el predicado LIKE y utiliza el mismo comportamiento de coincidencia de patrones y las mismas restricciones que el predicado LIKE.

El siguiente ejemplo utiliza el predicado NOT LIKE para recuperar documentos que tienen un valor title que no comienza con "The" de la colección sample_mflix.movies. Dado que el predicado coincide con la mayoría de los documentos, el ejemplo llama al método setMaxResults() para limitar el conjunto de resultados a cinco documentos:

var notLikeResult = session.createQuery("from Movie where title not like 'The%'", Movie.class)
                           .setMaxResults(5)
                           .getResultList();
for (var m : notLikeResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Civilization
Title: Grass: A Nation's Battle for Life
Title: Beau Geste
Title: Upstream
Title: Storm Over Asia

var notLikeResultEm = entityManager.createQuery("select m from Movie m where m.title not like 'The%'", Movie.class)
                                   .setMaxResults(5)
                                   .getResultList();
for (var m : notLikeResultEm) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Civilization
Title: Grass: A Nation's Battle for Life
Title: Beau Geste
Title: Upstream
Title: Storm Over Asia

La extensión Hibernate ORM traduce el predicado NOT LIKE anterior a la siguiente etapa $match:

{
  "$match": {
    "$nor": [
      { "title": { "$regex": /^The.*$/s } }
    ]
  }
}

ILIKE

El predicado ILIKE es la forma insensible a mayúsculas y minúsculas del predicado LIKE. La extensión Hibernate ORM marca el filtro $regex que produce el predicado LIKE como insensible a mayúsculas y minúsculas y utiliza el mismo comportamiento de coincidencia de patrones y las mismas restricciones que el predicado LIKE.

El siguiente ejemplo utiliza el predicado ILIKE para recuperar documentos que tienen un valor title que contiene "Star" de la colección sample_mflix.movies:

var ilikeResult = session.createQuery("from Movie where title ilike '%Star%'", Movie.class)
                         .getResultList();
for (var m : ilikeResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: The Stars Look Down
Title: A Star Is Born
Title: The Tin Star
Title: Marjorie Morningstar
Title: It Started in Naples

var ilikeResultEm = entityManager.createQuery("select m from Movie m where m.title ilike '%Star%'", Movie.class)
                                 .getResultList();
for (var m : ilikeResultEm) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: The Stars Look Down
Title: A Star Is Born
Title: The Tin Star
Title: Marjorie Morningstar
Title: It Started in Naples

La extensión Hibernate ORM traduce el predicado ILIKE anterior a la siguiente etapa $match:

{
  "$match": {
    "title": { "$regex": /^.*Star.*$/is }
  }
}

NO ME GUSTA

El predicado NOT ILIKE es la forma insensible a mayúsculas y minúsculas del predicado NOT LIKE. La extensión ORM de Hibernate niega el filtro $regex insensible a mayúsculas y minúsculas que produce el predicado ILIKE y utiliza el mismo comportamiento de coincidencia de patrones y las mismas restricciones que el predicado LIKE.

El siguiente ejemplo utiliza el predicado NOT ILIKE para recuperar documentos que tienen un valor title que no contiene "The" de la colección sample_mflix.movies. Dado que el predicado coincide con la mayoría de los documentos, el ejemplo llama al método setMaxResults() para limitar el conjunto de resultados a cinco documentos:

var notIlikeResult = session.createQuery("from Movie where title not ilike '%The%'", Movie.class)
                            .setMaxResults(5)
                            .getResultList();
for (var m : notIlikeResult) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Civilization
Title: Grass: A Nation's Battle for Life
Title: Beau Geste
Title: Upstream
Title: Storm Over Asia

var notIlikeResultEm = entityManager.createQuery("select m from Movie m where m.title not ilike '%The%'", Movie.class)
                                    .setMaxResults(5)
                                    .getResultList();
for (var m : notIlikeResultEm) {
    System.out.println("Title: " + m.getTitle());
}

...
Title: Civilization
Title: Grass: A Nation's Battle for Life
Title: Beau Geste
Title: Upstream
Title: Storm Over Asia

La extensión Hibernate ORM traduce el predicado NOT ILIKE anterior a la siguiente etapa $match:

{
  "$match": {
    "$nor": [
      { "title": { "$regex": /^.*The.*$/is } }
    ]
  }
}

Consultar un campo en un documento incrustado.

Puedes hacer referencia a un campo de un tipo incrustable usando una expresión de ruta con puntos en las cláusulas SELECT, WHERE, ORDER BY y UPDATE de una consulta HQL o JPQL. También puedes encadenar varios nombres de incrustables en una expresión de ruta para hacer referencia a un campo de un incrustable anidado dentro de otro incrustable.

El siguiente ejemplo utiliza una expresión de ruta para filtrar documentos en la colección sample_mflix.movies. Hay dos películas "Hairspray" en la colección sample_mflix.movies. Una película "Hairspray" es de 1998 y la otra es de 2007. La consulta coincide con los documentos que tienen un valor title igual a "Hairspray" y un valor awards.wins mayor que 10:

var matchingDocument = session.createQuery("from Movie where title = :title and awards.wins > :minWins", Movie.class)
        .setParameter("title", "Hairspray")
        .setParameter("minWins", 10)
        .getResultList();
for (var m : matchingDocument) {
    System.out.println("Title: " + m.getTitle() + ", Year: " + m.getYear());
}

Title: Hairspray, Year: 2007

var matchingDocument = entityManager.createQuery("select m from Movie m where m.title = :title and m.awards.wins > :minWins", Movie.class)
        .setParameter("title", "Hairspray")
        .setParameter("minWins", 10)
        .getResultList();
for (var m : matchingDocument) {
    System.out.println("Title: " + m.getTitle() + ", Year: " + m.getYear());
}

Title: Hairspray, Year: 2007

Consulta sobre elementos de una matriz incrustada

Cuando un campo de su entidad almacena una matriz de elementos incrustables agregados @Struct, puede usar una subconsulta EXISTS para encontrar documentos principales en los que al menos un elemento de esa matriz cumpla con sus criterios. La extensión Hibernate ORM traduce la subconsulta al operador $elemMatch de MongoDB, que aplica todos los criterios al mismo elemento de la matriz.

package org.example;
import com.mongodb.hibernate.annotations.ObjectIdGenerator;
import jakarta.persistence.Column;
import org.bson.types.ObjectId;
import java.util.List;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "restaurants")
public class Restaurant {
    @Id
    @ObjectIdGenerator
    @Column(name = "_id")
    private ObjectId id;
    private String name;
    private String borough;
    private List<Grade> grades;
    public Restaurant(String name, String borough, List<Grade> grades) {
        this.name = name;
        this.borough = borough;
        this.grades = grades;
    }
    public Restaurant() {
    }
    public ObjectId getId() {
        return id;
    }
    public void setId(ObjectId id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getBorough() {
        return borough;
    }
    public void setBorough(String borough) {
        this.borough = borough;
    }
    public List<Grade> getGrades() {
        return grades;
    }
    public void setGrades(List<Grade> grades) {
        this.grades = grades;
    }
}

package org.example;
import jakarta.persistence.*;
import org.hibernate.annotations.Struct;
@Embeddable
@Struct(name = "Grade")
public class Grade {
    private String grade;
    private int score;
    public Grade() {
        
    }
    public Grade(String grade, int score) {
        this.grade = grade;
        this.score = score;
    }
    public String getGrade() {
        return grade;
    }
    public void setGrade(String grade) {
        this.grade = grade;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
}

{
  "_id": { "$oid": "5eb3d668b31de5d588f4292a" },
  "name": "Morris Park Bake Shop",
  "borough": "Bronx",
  "cuisine": "Bakery",
  "grades": [
    { "date": { "$date": 1393804800000 }, "grade": "A", "score": 2 },
    { "date": { "$date": 1299715200000 }, "grade": "B", "score": 14 }
  ]
}

var existsResult = session.createQuery(
                "from Restaurant r where exists (select g.grade from r.grades g where g.grade = :grade and g.score = :score)",
                Restaurant.class)
        .setParameter("grade", "B")
        .setParameter("score", 12)
        .getResultList();
for (var r : existsResult) {
    System.out.println("Name: " + r.getName());
}

Name: Sam'S Restaurant
Name: Nb. National Bakery
Name: Sapporo Ichiban

var existsResultEm = entityManager.createQuery(
                "select r from Restaurant r where exists (select g.grade from r.grades g where g.grade = :grade and g.score = :score)",
                Restaurant.class)
        .setParameter("grade", "B")
        .setParameter("score", 12)
        .getResultList();
for (var r : existsResultEm) {
    System.out.println("Name: " + r.getName());
}

Name: Sam'S Restaurant
Name: Nb. National Bakery
Name: Sapporo Ichiban

{
  "$match": {
    "grades": {
      "$elemMatch": {
        "grade": { "$eq": "B" },
        "score": { "$eq": 12 }
      }
    }
  }
}