Especificar uma query

Dados de amostra

Os exemplos neste guia usam a entidade Movie, que representa a coleção sample_mflix.movies dos conjuntos de dados de amostra do Atlas. A entidade Movie tem a seguinte definição:

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 como criar um aplicativo Java que use a Extensão MongoDB para Hibernate ORM para interagir com essa coleção de amostras do MongoDB, veja o tutorial Get Started.

Os exemplos de código nesta página também usam o seguinte Awards @Struct agregado incorporável:

@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;

Compare Vários Campos de uma Só Vez

Um predicado de valor de linha compara uma lista de campos entre parênteses com uma lista de valores entre parênteses em uma única expressão. A extensão Hibernate ORM oferece suporte a predicados de valor de linha que usam os seguintes operadores:

• =: Correspondência de igualdade

• <>: Correspondência de desigualdade

• IN e NOT IN: Correspondência com uma lista de linhas de valores

Você pode fornecer os valores como parâmetros vinculados ou como literais, e cada lista deve conter o mesmo número de componentes.

O exemplo a seguir recupera documentos que têm um valor "Jurassic World" para title e um valor 2015 para year da coleção 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

A extensão Hibernate ORM compara cada par de componentes separadamente. O predicado de valor de linha anterior é traduzido para o seguinte estágio $match:

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

Um predicado de valor de linha que usa o operador <> é traduzido para a mesma expressão $and envolvida em uma expressão $nor.

Se você comparar os campos com outra lista de campos, como em where (title1, year1) = (title2, year2), a extensão Hibernate ORM traduz o predicado para uma expressão $expr.

Você pode usar um predicado de valor de linha em uma cláusula SELECT. O predicado é avaliado como um valor booleano na projeção.

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 WorldTitle: 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 WorldTitle: Ex Machina

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

Comparar valores de campo com nulo

Ao comparar um campo com null usando um operador de comparação, a extensão Hibernate ORM aplica a semântica nula da MongoDB linguagem de query em vez da lógica ternária que o Hibernate ORM define.

Os operadores de comparação do MongoDB avaliam tanto um campo ausente quanto um campo que armazena um valor explícito de null como null. Como resultado, uma comparação = null corresponde a documentos em que o campo armazena null e documentos em que o campo está ausente. Uma comparação <> null ou != null corresponde a documentos em que o campo armazena qualquer outro valor.

O exemplo a seguir usa o operador = para recuperar documentos que têm um valor null ou ausente cast da coleção 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 LahoreTitle: A Sinner in MeccaTitle: 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 LahoreTitle: A Sinner in MeccaTitle: Very Semi-Serious

A extensão Hibernate ORM traduz esta query para o seguinte estágio $match:

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

As comparações que usam os operadores >, >=, < e <= seguem a ordem de comparação BSON do MongoDB para campos inexistentes. Como null é seu próprio tipo BSON, uma comparação >= null ou <= null corresponde a documentos nos quais o campo armazena null ou está ausente. Uma comparação > null ou < null não corresponde a nenhum documento.

Para corresponder a null e valores ausentes usando um predicado em vez de um operador de comparação, consulte as seções IS NULL e IS NOT NULL deste guia.

Realizar cálculos aritméticos em uma projeção

Ao selecionar uma expressão computada, a extensão Hibernate ORM adiciona o valor computado ao estágio $project. Se você atribuir um alias à expressão usando a palavra-chave AS, a extensão Hibernate ORM usará o alias como a chave de projeção. Caso contrário, ele gera uma chave no formato #c_<n>.

O exemplo a seguir calcula a idade de cada filme "Hairspray" na coleção sample_mflix.movies subtraindo o valor do campo year de um parâmetro de query:

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: 38Title: 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: 38Title: Hairspray, Age: 19

A extensão Hibernate ORM traduz a expressão computada anterior para o seguinte estágio $project:

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

Filtro em uma expressão computada

Na cláusula WHERE, você pode comparar uma expressão calculada com um valor ou comparar dois valores de campo entre si. Quando qualquer um dos lados de uma comparação não é uma referência de campo direta ou um valor, a extensão Hibernate ORM envolve a comparação no operador $expr do MongoDB. As comparações entre um campo e um valor continuam a usar a forma compacta { field: { operator: value } }.

O exemplo a seguir recupera "Hairspray" filmes lançados menos de 20 anos 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

A extensão Hibernate ORM traduz a query anterior para o seguinte estágio $match, no qual a comparação title usa a forma compacta e a comparação calculada usa $expr:

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

Projeto um resultado de comparação

Você pode usar uma comparação em uma declaração SELECT para retornar seu resultado booleano em vez de usar a comparação como um filtro.

O exemplo a seguir retorna o título de cada filme "Hairspray" e se o filme foi lançado após 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: falseTitle: 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: falseTitle: Hairspray, Recent: true

A extensão Hibernate ORM traduz a comparação anterior para o seguinte estágio $project:

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

Existe

O predicado EXISTS corresponde a documentos que possuem um campo específico e retorna apenas um resultado para cada documento pai correspondente, independentemente de quantos elementos do array correspondam.

Para um exemplo completo, consulte a seção Query em elementos de um array incorporado deste guia.

entre

O predicado BETWEEN corresponde a documentos que têm um valor de campo dentro de uma faixa especificada.

O exemplo a seguir usa o predicado BETWEEN para recuperar documentos que têm um valor year entre 2012 e 2013, inclusive, da coleção 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 MindedTitle: The Disappearance of Eleanor Rigby: HerTitle: 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 MindedTitle: The Disappearance of Eleanor Rigby: HerTitle: Thread of Lies

A extensão Hibernate ORM traduz o predicado BETWEEN anterior para o seguinte estágio $match:

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

Em

O predicado IN corresponde a documentos em que o valor de um campo é igual a qualquer valor em uma lista especificada. Você pode fornecer os valores da lista como literais, parâmetros nomeados ou parâmetros posicionais.

O exemplo a seguir usa o predicado IN para recuperar documentos que têm um valor year de 1994 ou 1996 da coleção 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 KottaiTitle: GottiTitle: 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 KottaiTitle: GottiTitle: It's Just a Ride

A extensão Hibernate ORM traduz o predicado IN anterior para o seguinte estágio $match:

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

Uma lista vazia é válida, mas nunca corresponde a nenhum documento. Por exemplo, year in () não corresponde a nenhum documento.

não em

O predicado NOT IN corresponde a documentos nos quais um valor de campo não é igual a nenhum valor em uma lista especificada. NOT IN aceita as mesmas formas de lista e tem as mesmas limitações que o predicado IN.

O exemplo a seguir usa o predicado NOT IN para recuperar documento que tenham um valor title diferente de "Romeo and Juliet" ou "Best in Show" da coleção sample_mflix.movies. Como NOT IN exclui apenas os valores listados, o exemplo chama o método setMaxResults() para limitar o conjunto de resultados a dez documento:

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 XmasTitle: 'Round MidnightTitle: '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 XmasTitle: 'Round MidnightTitle: 'Til Madness Do Us Part

A extensão Hibernate ORM traduz o predicado NOT IN anterior para o seguinte estágio $match:

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

Como $nin corresponde a cada documento em relação a uma lista vazia de valores, title not in () corresponde a todos os documentos.

IsNull

O predicado IS NULL corresponde a documentos que possuem um campo específico com um valor nulo ou ausente.

Para comparar um campo com null usando um operador de comparação em vez de um predicado, consulte a seção Comparar valores de campo com nulo deste guia.

O exemplo a seguir usa o predicado IS NULL para recuperar documentos que têm um valor cast ausente ou null da coleção 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 RifleTitle: A Sinner in MeccaTitle: 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 RifleTitle: A Sinner in MeccaTitle: Very Semi-Serious

A extensão Hibernate ORM traduz o predicado IS NULL anterior para o estágio $match a seguir, que corresponde a documentos onde o campo é explicitamente null ou está ausente:

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

IS NOT NULL

O predicado IS NOT NULL corresponde a documentos que têm um campo com um valor não nulo ou não ausente.

O exemplo a seguir usa o predicado IS NOT NULL para recuperar documentos que têm um valor directors da coleção 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 OnesTitle: No Home MovieTitle: 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 OnesTitle: No Home MovieTitle: Scenes of a Sexual Nature

A extensão Hibernate ORM traduz o predicado IS NOT NULL anterior para o estágio $match a seguir, que corresponde a documentos onde o campo existe e não é explicitamente null:

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

semelhante a

O predicado LIKE diferencia maiúsculas de minúsculas e corresponde a documentos onde um valor de campo corresponde a um padrão especificado. O padrão é aplicado a todo o valor do campo e pode usar os seguintes caracteres wildcard:

• %: Corresponde a zero ou mais caracteres.

• _: Corresponde exatamente a um caractere.

Para corresponder a um prefixo, inclua % no final do padrão e, para corresponder a um sufixo, inclua % no início do padrão.

O exemplo a seguir usa o predicado LIKE para recuperar documentos que têm um valor title que começa com "W", seguido por qualquer caractere único e depois "r", da coleção 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 PeaceTitle: WarlockTitle: WarrendaleTitle: WarGamesTitle: 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 PeaceTitle: WarlockTitle: WarrendaleTitle: WarGamesTitle: Working Girl

A extensão Hibernate ORM traduz o predicado LIKE anterior para o seguinte estágio $match:

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

Para aprender mais sobre o predicado HQL LIKE, consulte Um Guia da linguagem de query do Hibernate na documentação do ORM do Hibernate.

NOT LIKE

O predicado NOT LIKE corresponde a documentos nos quais um valor de campo não corresponde ao padrão especificado. A extensão Hibernate ORM nega o filtro $regex que o predicado LIKE produz e usa o mesmo comportamento e restrições de correspondência de padrão que o predicado LIKE.

O exemplo a seguir usa o predicado NOT LIKE para recuperar documentos que têm um valor title que não começa com "The" da coleção sample_mflix.movies. Como o predicado corresponde à maioria dos documentos, o exemplo chama o método setMaxResults() para limitar o 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: CivilizationTitle: Grass: A Nation's Battle for LifeTitle: Beau GesteTitle: UpstreamTitle: 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: CivilizationTitle: Grass: A Nation's Battle for LifeTitle: Beau GesteTitle: UpstreamTitle: Storm Over Asia

A extensão Hibernate ORM traduz o predicado NOT LIKE anterior para o seguinte estágio $match:

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

ILIKE

O predicado ILIKE é a forma que não diferencia maiúsculas de minúsculas do predicado LIKE. A extensão Hibernate ORM marca o filtro $regex que o predicado LIKE produz como não diferenciando maiúsculas de minúsculas e usa o mesmo comportamento de correspondência de padrão e restrições que o predicado LIKE.

O exemplo a seguir usa o predicado ILIKE para recuperar documentos que têm um valor title contendo "Star" da coleção 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 DownTitle: A Star Is BornTitle: The Tin StarTitle: Marjorie MorningstarTitle: 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 DownTitle: A Star Is BornTitle: The Tin StarTitle: Marjorie MorningstarTitle: It Started in Naples

A extensão Hibernate ORM traduz o predicado ILIKE anterior para o seguinte estágio $match:

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

NOT ILIKE

O predicado NOT ILIKE é a forma que não diferencia maiúsculas de minúsculas do predicado NOT LIKE. A extensão Hibernate ORM nega o filtro $regex que não diferencia maiúsculas de minúsculas que o predicado ILIKE produz e usa o mesmo padrão de correspondência e restrições que o predicado LIKE.

O exemplo a seguir usa o predicado NOT ILIKE para recuperar documentos que têm um valor title que não contém "The" da coleção sample_mflix.movies. Como o predicado corresponde à maioria dos documentos, o exemplo chama o método setMaxResults() para limitar o 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: CivilizationTitle: Grass: A Nation's Battle for LifeTitle: Beau GesteTitle: UpstreamTitle: 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: CivilizationTitle: Grass: A Nation's Battle for LifeTitle: Beau GesteTitle: UpstreamTitle: Storm Over Asia

A extensão Hibernate ORM traduz o predicado NOT ILIKE anterior para o seguinte estágio $match:

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

Query um campo em um documento incorporado

Você pode referenciar um campo em um tipo incorporável usando uma expressão de caminho pontilhado nas cláusulas SELECT, WHERE, ORDER BY e UPDATE de uma query HQL ou JPQL. Você também pode encadear vários nomes incorporáveis em uma expressão de caminho para referenciar um campo em um incorporável aninhado dentro de outro incorporável.

O exemplo a seguir usa uma expressão de caminho para filtrar documentos na coleção sample_mflix.movies. Existem dois filmes "Hairspray" na coleção sample_mflix.movies. Um filme "Hairspray" é de 1998 e o outro é de 2007. A query corresponde a documentos que têm um valor "Hairspray" para title e um valor 10 maior que awards.wins:

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

Query em elementos de um array incorporado

Quando um campo da sua entidade armazena um array de @Struct aggregate embeddables, você pode usar uma subconsulta EXISTS para corresponder a documentos pai nos quais pelo menos um elemento desse array atenda aos seus critérios. A extensão Hibernate ORM traduz a subconsulta para o operador $elemMatch do MongoDB, que aplica todos os critérios ao mesmo elemento de array.

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 RestaurantName: Nb. National BakeryName: 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 RestaurantName: Nb. National BakeryName: Sapporo Ichiban

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