TOC

Classificando com JPA

Classificando com JPA

*1. Visão geral *

Este artigo ilustra a maneira como o JPA pode ser usado para classificar* .

Leitura adicional:

https://www..com/spring-data-jpa-query [Spring Data JPA @Query]

Aprenda a usar a anotação @Query no Spring Data JPA para definir consultas personalizadas usando JPQL e SQL nativo.

https://www..com/spring-data-jpa-query [Leia mais] →

https://www..com/jpa-attribute-converters [Conversores de atributo JPA]

Dê uma olhada no mapeamento de tipos JDBC para classes Java no JPA usando conversores de atributos.

https://www..com/jpa-attribute-converters [Leia mais] →

https://www..com/kotlin-jpa [Trabalhando com Kotlin e JPA]

Aprenda como você pode usar o JPA em seu projeto Kotlin.

https://www..com/kotlin-jpa [Leia mais] →

*2. Classificação com API JPA/JQL *

O uso do JQL para classificar é feito com a ajuda da cláusula Order By:

String jql ="Select f from Foo as f order by f.id";
Query query = entityManager.createQuery (jql);

Com base nesta consulta, o JPA gera a seguinte instrução* SQL *direta:

Hibernate: select foo0_.id as id1_4_, foo0_.name as name2_4_
    from Foo foo0_ order by foo0_.id

Observe que as palavras-chave SQL na cadeia JQL não diferenciam maiúsculas de minúsculas, mas os nomes das entidades e seus atributos.

====* 2.1 Definindo a ordem de classificação *

Por padrão* , a ordem de classificação é crescente *, mas pode ser explicitamente configurada na cadeia JQL. Assim como no SQL puro, as opções de pedidos são asc e desc:

String jql = "Select f from Foo as f order by f.id desc";
Query sortQuery = entityManager.createQuery(jql);

A consulta SQL gerada incluirá a direção do pedido:

Hibernate: select foo0_.id as id1_4_, foo0_.name as name2_4_
    from Foo foo0_ order by foo0_.id desc

2.2 Classificando por mais de um atributo

Para classificar por vários atributos, eles são adicionados à cláusula order by da cadeia JQL:

String jql ="Select f from Foo as f order by f.name asc, f.id desc";
Query sortQuery = entityManager.createQuery(jql);

Ambas as condições de classificação aparecerão na instrução query SQL gerada :

Hibernate: select foo0_.id as id1_4_, foo0_.name as name2_4_
    from Foo foo0_ order by foo0_.name asc, foo0_.id desc

2.3 Definindo a precedência de classificação de valores nulos

A precedência padrão de nulos é específica do banco de dados, mas isso é personalizável através da cláusula NULLS FIRST ou NULLS LAST na cadeia de consulta HQL.

Aqui está um exemplo simples - ordenando por name de Foo em ordem decrescente e colocando Nulls no final:

Query sortQuery = entityManager.createQuery
    ("Select f from Foo as f order by f.name desc NULLS LAST");

A consulta SQL gerada inclui a is nula a cláusula 1 else 0 end (terceira linha):

Hibernate: select foo0_.id as id1_4_, foo0_.BAR_ID as BAR_ID2_4_,
    foo0_.bar_Id as bar_Id2_4_, foo0_.name as name3_4_,from Foo foo0_ order
    by case when foo0_.name is null then 1 else 0 end, foo0_.name desc

2.4. Classificando um para muitos relacionamentos

Passando os exemplos básicos, agora vamos ver um caso de uso envolvendo classificação de entidades em uma relação de um para muitos - Bar contendo uma coleção de Foo entidades.

Queremos classificar as entidades Bar e também sua coleção de entidades Foo - o JPA é especialmente simples para esta tarefa:

  1. Classificando a coleção: adicione uma anotação OrderBy que precede a coleção Foo na entidade Bar:

@OrderBy("name ASC")
List <Foo> fooList;

  1. Classificando a entidade que contém a coleção:

String jql = "Select b from Bar as b order by b.id";
Query barQuery = entityManager.createQuery(jql);
List<Bar> barList = barQuery.getResultList();

Observe que a anotação _ @ OrderBy_ é opcional, mas a estamos usando neste caso porque queremos classificar a coleção Foo de cada Bar.

Vamos dar uma olhada na consulta SQL enviada ao RDMS:

Hibernate: select bar0_.id as id1_0_, bar0_.name as name2_0_ from Bar bar0_ order by bar0_.id

Hibernate:
select foolist0_.BAR_ID as BAR_ID2_0_0_, foolist0_.id as id1_4_0_,
foolist0_.id as id1_4_1_, foolist0_.BAR_ID as BAR_ID2_4_1_,
foolist0_.bar_Id as bar_Id2_4_1_, foolist0_.name as name3_4_1_
from Foo foolist0_
where foolist0_.BAR_ID=? order by foolist0_.name asc

A primeira consulta classifica a entidade Bar pai. A segunda consulta é gerada para classificar a coleção de entidades filho Foo pertencentes a Bar.

*3. Classificação com a API do Objeto de Consulta de Critérios JPA *

Com os Critérios JPA - o método orderBy é uma alternativa de “uma parada” para definir todos os parâmetros de classificação: tanto a* direção da ordem quanto os atributos a serem classificados * podem ser definidos. A seguir está a API do método:

  • orderBy _ (

Related