Peut JPA retourner des résultats sur une carte?

Nous sommes actuellement en train de construire une map manuelle basée sur les deux champs d'une requête nommée retourne, parce que JPA ne fournit qu'une getResultList().

@NamedQuery{name="myQuery",query="select c.name, c.number from Client c"}

HashMap<Long,String> myMap = new HashMap<Long,String>();

for(Client c: em.createNamedQuery("myQuery").getResultList() ){
     myMap.put(c.getNumber, c.getName);
}

Mais je me sens comme une coutume mappeur ou similaire serait plus performant depuis cette liste pourrait facilement être 30,000+ résultats.

Toutes les idées pour construire une Carte sans itération manuellement.

(Je suis en utilisant OpenJPA, pas de mise en veille prolongée)

Ce qui serait utilisée en tant que votre Carte de clé?
Comme le montre le code,le numéro de champ (Long), une des deux valeurs retournées. Mais je ne pouvais vivre avec n'importe quel Type, tant que la clé est le nombre et la valeur est le nom. J'ai ajouté la déclaration pour plus de détails.

InformationsquelleAutor Eddie | 2010-12-06

15

Il n'existe pas de méthode standard pour obtenir JPA pour retourner une carte.

voir question à ce sujet: JPA 2.0 natif de résultats de la requête comme carte

Itération manuellement doit être fine. Le temps à la parcourir une liste ou une carte de mémoire va être petit par rapport au temps d'exécution/retour les résultats de la requête. Je ne voudrais pas essayer de futz avec la JPA des éléments internes ou de personnalisation sauf s'il y a une preuve concluante que le manuel de l'itération n'était pas réalisable.

Aussi, si vous avez d'autres endroits où vous tournez résultat de la requête dans les Listes de Cartes, vous voulez probablement à refactoriser que dans un utilitaire de méthode avec un paramètre pour indiquer la carte de propriété de la clé.

InformationsquelleAutor wrschneider
8

Vous pouvez récupérer une liste de java.util.Carte.Entrée à la place.
Par conséquent, la collecte dans votre entité doit être modélisé comme une Carte:
```
@OneToMany
@MapKeyEnumerated(EnumType.STRING)
public Map<PhoneType, PhoneNumber> phones;
```
Dans l'exemple PhoneType est une simple énumération, un Numéro de téléphone est une entité. Dans votre requête, utilisez la ENTRY mot-clé qui a été introduit dans JPA 2.0 pour carte des opérations:
```
public List<Entry> getPersonPhones(){
    return em.createQuery("SELECT ENTRY(pn) FROM Person p JOIN p.phones pn",java.util.Map.Entry.class).getResultList();
}
```
Vous êtes maintenant prêt à récupérer les entrées et commencer à travailler avec elle:
```
List<java.util.Map.Entry> phoneEntries =   personDao.getPersonPhoneNumbers();
for (java.util.Map.Entry<PhoneType, PhoneNumber> entry: phoneEntries){
    //entry.key(), entry.value()
}
```
Si vous avez encore besoin d'entrées dans une carte, mais ne veulent pas parcourir la liste de vos entrées manuellement, jetez un oeil sur ce post Convertir Set<Map.Entrée<K, V>> pour HashMap<K, V> qui fonctionne avec Java 8.

InformationsquelleAutor mika

Cela fonctionne bien.

Référentiel de code :

@Repository
public interface BookRepository extends CrudRepository<Book,Id> {

    @Query("SELECT b.name, b.author from Book b")
    List<Object[]> findBooks();
}

service.java

      List<Object[]> list = bookRepository.findBooks();
                for (Object[] ob : list){
                    String key = (String)ob[0];
                    String value = (String)ob[1];
}

lien https://codereview.stackexchange.com/questions/1409/jpa-query-to-return-a-map

c'est exactement ce que l'OP veut éviter
un client mappeur serait aussi de faire la même chose derrière les coulisses.

InformationsquelleAutor krishna Murari

0

Comment à ce sujet ?
```
@NamedNativeQueries({
@NamedNativeQuery(
  name="myQuery",
  query="select c.name, c.number from Client c",
  resultClass=RegularClient.class
)
})
```
et
```
     public static List<RegularClient> runMyQuery() {
     return entityManager().createNamedQuery("myQuery").getResultList();
 }
```
- merci, mais cela renvoie une liste.. Le problème est que j'ai besoin d'utiliser les résultats à l'intérieur d'une autre méthode et le besoin d'une recherche rapide de la méthode.. j'ai pensé à une carte woul être la meilleure façon de le faire.
InformationsquelleAutor zawhtut

À la coutume résultat class et un peu de Goyave, c'est mon approche qui fonctionne très bien:

public static class SlugPair {
    String canonicalSlug;
    String slug;

    public SlugPair(String canonicalSlug, String slug) {
        super();
        this.canonicalSlug = canonicalSlug;
        this.slug = slug;
    }

}

...

final TypedQuery<SlugPair> query = em.createQuery(
    "SELECT NEW com.quikdo.core.impl.JpaPlaceRepository$SlugPair(e.canonicalSlug, e.slug) FROM "
      + entityClass.getName() + " e WHERE e.canonicalSlug IN :canonicalSlugs",
    SlugPair.class);

query.setParameter("canonicalSlugs", canonicalSlugs);

final Map<String, SlugPair> existingSlugs = 
    FluentIterable.from(query.getResultList()).uniqueIndex(
        new Function<SlugPair, String>() {
    @Override @Nullable
    public String apply(@Nullable SlugPair input) {
        return input.canonicalSlug;
    }
});

InformationsquelleAutor Hendy Irawan

Veuillez vous référer, JPA 2.0 natif de résultats de la requête comme carte

Dans votre cas dans Postgres, il serait quelque chose comme,

List<String> list = em.createNativeQuery("select cast(json_object_agg(c.number, c.name) as text) from schema.client c")
                   .getResultList();

//handle exception here, this is just sample
Map map = new ObjectMapper().readValue(list.get(0), Map.class);

Veuillez noter, je suis juste partage de ma solution avec Postgres.

InformationsquelleAutor Darshan Patel

Map<String,Object> map = null;
    try {
        EntityManager entityManager = getEntityManager();
        Query query = entityManager.createNativeQuery(sql);
            query.setHint(QueryHints.RESULT_TYPE, ResultType.Map);
        map = (Map<String,Object>) query.getSingleResult();
    }catch (Exception e){ }

 List<Map<String,Object>> list = null;
    try {
        EntityManager entityManager = getEntityManager();
        Query query = entityManager.createNativeQuery(sql);
            query.setHint(QueryHints.RESULT_TYPE, ResultType.Map);
            list = query.getResultList();
    }catch (Exception e){  }

InformationsquelleAutor Tufik Chediak

Vous devez vous connecter pour publier un commentaire.