org.mise en veille prolongée.hql.ast.QueryTranslatorImpl liste à l'ATTENTION de: firstResult/maxResults spécifié à la collecte de l'extraction; l'application dans la mémoire

TL;DR Hibernate ne sais pas combien de lignes de aplaties, rejoint la requête qu'il a besoin pour obtenir le nombre spécifié de l'Ordre des objets, de sorte qu'il a à charge de la totalité de la requête dans la mémoire. Voir ci-dessous pour une explication.

De comprendre pourquoi Hibernate pour cela, vous devez comprendre comment Hibernate ne l'ORM (Object-Relational Mapping) impliqués pour des Entités JPA.

Envisager une simplification de la configuration des Entités de votre commande. Classe Order contient 2 champs: number et customerId et une liste des lignes de commande. Classe OrderLine contient productCode et quantity champs, ainsi que d'un uid clé et une référence à la société mère de l'Ordre.

Ces classes peuvent être définies ainsi:

@Entity
@Table(name = "ORDER")
public class Order {
    @ID
    @Column(name = "NUMBER")
    private Integer number;
    @Column(name = "CUSTOMER_ID")
    private Integer customerId;
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
    @OrderBy
    private List<OrderLine> orderLineList;

    .... //Rest of the class
}

@Entity
@Table(name = "ORDER_LINE")
public class OrderLine
{
    @ID
    @Column(name = "UID")
    private Integer uid;
    @Column(name = "PRODUCT_CODE")
    private Integer productCode;
    @Column(name = "QUANTITY")
    private Integer quantity;
    @Column(name = "ORDER_NUMBER")
    private Integer orderNumber;
    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "ORDER_NUMBER", referencedColumnName = "NUMBER", insertable = false, updatable = false)
    private Order order;

    .... //Rest of the class
}

Maintenant, si vous avez effectué la suite de la requête JPQL sur ces Entités:

SELECT o FROM Order o LEFT JOIN FETCH o.orderLineList

puis Hibernate effectue cette requête comme une "aplaties" requête SQL similaire à la suivante:

SELECT o.number, o.customer_id, ol.uid, ol.product_code, ol.quantity, ol.order_number
FROM order o LEFT JOIN order_line ol ON order_line.order_number = order.number

qui donnerait un résultat de ce genre:

| o.number | o.customer_id | ol.uid | ol.product_code | ol.quantity |
|==========|===============|========|=================|=============|
| 1        | 123           | 1      | 1111            | 5           |
| 1        | 123           | 2      | 1112            | 6           |
| 1        | 123           | 3      | 1113            | 1           |
| 2        | 123           | 4      | 1111            | 2           |
| 2        | 123           | 5      | 1112            | 7           |
| 3        | 123           | 6      | 1111            | 6           |
| 3        | 123           | 7      | 1112            | 5           |
| 3        | 123           | 8      | 1113            | 3           |
| 3        | 123           | 9      | 1114            | 2           |
| 3        | 123           | 10     | 1115            | 9           |
...etc

qui Hibernate serait l'utilisation de 'reconstruire' Order objets connectés à des listes de OrderLine des sous-objets.

Cependant, puisque le nombre de lignes de commandes par ordre est aléatoire, il n'existe aucun moyen pour Hibernate pour connaître le nombre de lignes de cette requête à prendre pour obtenir le nombre maximal spécifié de Order les objets requis. Donc, il doit prendre la totalité de la requête et de construire les objets en mémoire jusqu'à ce qu'il a le droit montant, avant de jeter le reste de l'ensemble de résultats. Le journal avertissement ce produit fait allusion à ceci:

ATTENTION: firstResult/maxResults specified with collection fetch; applying in memory!

Nous sommes seulement en train de découvrir maintenant que ces requêtes peuvent avoir un impact significatif sur le serveur de l'utilisation de la mémoire, et nous avons eu des problèmes avec notre serveur de tomber avec des erreurs de mémoire insuffisante lors de ces requêtes sont tentées.

Par le chemin, je vais dire maintenant que c'est principalement de la théorie de ma part et je n'ai aucune idée de comment le réel Hibernate code fonctionne. La plupart de ce que vous pouvez glaner dans les journaux lorsque vous avez Hibernate journalisation des requêtes SQL qu'il génère.

---

Mise à JOUR:
Récemment, j'ai découvert un peu "chasse aux sorcières" avec la ci-dessus.

Envisager une troisième Entité appelée Shipment qui est pour une ou plusieurs Lignes de Commande.

La Shipment entité aurait un @ManyToOne association pour la Order entité.

Disons que vous avez 2 Envois pour la même Commande qui dispose de 4 Lignes.

Si vous effectuez une requête JPQL pour les éléments suivants:

SELECT s FROM Shipment s LEFT JOIN s.order o LEFT JOIN FETCH o.orderLineList

Vous attendent (ou au moins je l'ai fait) pour obtenir 2 de l'envoi des objets de dos, chacun avec une référence au même objet de Commande, qui lui-même contient les 4 Lignes.

Nope, de nouveau mal! En fait, vous obtenez 2 Envoi d'objets, chacun se référant à la même Ordre d'objet, qui contient 8 Lignes! Oui, les Lignes se dupliqué dans l'Ordre! Et oui, c'est à dire même si vous spécifiez la clause DISTINCT.

Si vous cette question de la recherche ici ou ailleurs (et notamment la veille prolongée forums), vous verrez que c'est en fait un fonction pas un bug, selon les Hibernate pouvoirs en place. Certaines personnes effectivement voulez ce comportement!

Allez comprendre.

OriginalL'auteur DuncanKinnear

setMaxResult(10) encapsule la requête avec une autre limitation de résultat, par exemple pour oracle:

select * from ("votre requête ici") where rownum<10

J'ai trouvé que c'aujourd'hui lors de l'enquête de la requête qui a eu 64 secondes, maintenant, il faut 1 seconde.

...la même chose pour les critères.setProjection(Projections.rowCount()).setMaxResults(10)

OriginalL'auteur nigi