differenza tra query.list e query.iterate

Question

Qual è esattamente la differenza tra l'utilizzo di Query.list() e Query.iterator()?

Esiste un miglioramento delle prestazioni nell'utilizzo di entrambi. Voglio dire che nessuno di loro implementa lo lazy loading?

O è Query.iterator() definitiva stessa query.list().iterate()

Inoltre Perché non c'è Criteria.iterator() solo Criteria.list()

Answer 1

Se le istanze sono già nella sessione (cache di livello primario) o cache di secondo livello iterate() darà prestazioni migliori.

Se non sono già memorizzati nella cache, iterate() sarà più lento di list() e potrebbe richiedere molti hit del database per una semplice query.

Answer 2

JavaDoc dice:

restituire i risultati della query come un iteratore. Se la query contiene più risultati prima della riga, i risultati vengono restituiti in un'istanza di Object [].

Entità restituite poiché i risultati vengono inizializzati su richiesta. La prima query SQL restituisce solo identificatori.

(sottolineatura mia)

Answer 3

Query.list(): Esegue 1 query SQL e carica l'intero dato. Anche se i record sono presenti nella cache, viene eseguita una nuova query SQL per caricare i record dal database.

List<Employee> list1 = session.createQuery("from Employee").list(); // SELECT *FROM EMP 
for (Employee e : list1) { 
    System.out.println(e); 
} 
List<Employee> list2 = session.createQuery("from Employee").list(); // SELECT *FROM EMP 
for (Employee e : list2) { 
    System.out.println(e); 
} 

Query.iterate(): Esegue 1 + N query SQL. La prima query restituisce solo l'identificativo di tutti i record e quando l'iteratore restituito viene iterato ogni volta che viene eseguita una query SQL separata che contiene una clausola WHERE come "WHERE id = N". Se i record sono presenti nella cache, viene eseguita la prima query e le restanti N query non vengono eseguite e i record vengono ottenuti dalla cache.

Iterator<Employee> iterator1 = session.createQuery("from Employee").iterate(); // SELECT EMP_ID FROM EMP 
while(iterator1.hasNext()) { 
    System.out.println(iterator1.next()); // SELECT * FROM EMP WHERE EMP_ID=? 
} 
Iterator<Employee> iterator2 = session.createQuery("from Employee").iterate(); // SELECT EMP_ID FROM EMP 
while (iterator2.hasNext()) { 
    System.out.println(iterator2.next()); // From cache, no SQL 
} 

Answer 4

+----------------------------------------------+-----------------------------------------------+ 
|     list()     |     iterate()     | 
+----------------------------------------------+-----------------------------------------------+ 
| Return type is List       | Return type is Iterate      | 
| All records loads at single database request | For each record, one database hit is made  | 
| This is faster if cache is not available  | This is very slower if cache is not available | 
| Eager loading        | Lazy loading         | 
+----------------------------------------------+-----------------------------------------------+ 

Per la lista():

Query query = session.createQuery("from Employee"); 
List list = query.list(); // SELECT * FROM EMP 
Iterator iterator = list.iterator(); 
while(iterator.hasNext()){ 
} 

Per iterate():

Query query = session.createQuery("from Employee"); 
Iterator iterator = query.iterate(); // SELECT * FROM EMP 
while(iterator.hasNext()){ 
    // SELECT * FROM EMP WHERE EMP_ID=? 
}