Comment interroger pour les valeurs de la Carte avec Spring Data JPA?

donc mon modèle de base de données qui va comme ceci: j'ai Stores et tous les Store a un nom localisé. J'ai donc choisi pour représenter le nom localisé comme un Map comme ceci:

public class Store {
   private Map<Locale,LocalizedValue> name;
}

comme vous pouvez le voir c'est une Carte de <Locale, LocalizedValue> où la LocalizedValue est une classe comme ceci:

@Embeddable
public class LocalizedValue {

   @Column(name = "value")
   private String value;
}

et tout fonctionne très bien. Mais j'ai un problème lorsque je veux requête de mon Ressort des Données JPA référentiel et de trouver tous les magasins avec un nom anglais. Donc, mon référentiel méthode ressemble à ceci:

Store findByName(Map.Entry<Locale, LocalizedValue> name);

mais elle en jette cette exception:

 2014-10-07 23:49:55,862 [qtp354231028-165] ERROR: Parameter value [en=Some Value] did not match expected type [com.test.LocalizedValue(n/a)]; nested exception is java.lang.IllegalArgumentException: Parameter value [en=Some Value] did not match expected type [com.test.LocalizedValue (n/a)]
org.springframework.dao.InvalidDataAccessApiUsageException: Parameter value [en=Some Value] did not match expected type [com.test.LocalizedValue (n/a)]; 
nested exception is java.lang.IllegalArgumentException: Parameter value [en=Some Value] did not match expected type [com.test.LocalizedValue (n/a)]
    at org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:384)
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:216)
    at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.translateExceptionIfPossible(AbstractEntityManagerFactoryBean.java:417)
    at org.springframework.dao.support.ChainedPersistenceExceptionTranslator.translateExceptionIfPossible(ChainedPersistenceExceptionTranslator.java:59)
    at org.springframework.dao.support.DataAccessUtils.translateIfNecessary(DataAccessUtils.java:213)

Alors j'ai changé mon référentiel méthode pour être comme ceci:

Store findByName(LocalizedValue name);

mais j'ai eu cette exception:

Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unknown column 'name1_.pk' in 'where clause'
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:526)

J'ai aussi essayé d'utiliser, Contient, dans la méthode de requête - toujours pas de chance.

Donc ma question est: Est-il un moyen pour rechercher les magasins avec un nom anglais 'Valeur'?

OriginalL'auteur Petar Tahchiev | 2014-10-07

7

Cela nécessite un définies manuellement requête à quelque chose comme ceci:
```
interface StoreRepository extends Repository<Store, Long> {

  @Query("select s from Store s join s.map m where ?1 in (VALUE(m))"
  Optional<Store> findByName(String name);
}
```
Il raconte essentiellement le fournisseur de persistance d'étendre les valeurs de la carte et de vérifier si le paramètre donné est dans la liste de l'expansion des valeurs.

Merci pour votre réponse. Est-ce documenté au Printemps JPA ? Où puis-je obtenir plus d'informations sur la façon dont les valeurs de la carte sont développées par Spring JPA.
Peut même être fait avec la Collection de paramètre?

OriginalL'auteur Oliver Drotbohm

Vous n'avez pas posté votre mappages mais il me semble être un problème fondamental avec la façon que Embeddables sont munis d'un détrompeur.

C'est la seule façon évidente que je peux voir sur la carte l'association:

@Entity
@Table(name = "stores")
public class Store {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private Long id;

    @ElementCollection
    @CollectionTable(name = "store_names", joinColumns = @JoinColumn(name = "store_id"))
    @MapKeyColumn(name = "locale")
    private Map<Locale, LocalizedName> names;

    public Map<Locale, LocalizedName> getNames() {
        return names;
    }

    public String getName(Locale locale) {
        return names.get(locale).getName();
    }
}


@Embeddable
public class LocalizedName {

    @Column(name = "name")
    private String name;

    @SuppressWarnings("unused")
    private LocalizedName() {

    }

    public LocalizedName(String name) {
        this.name = name;
    }

    public String getName(){
        return name;
    }
}

Le test suivant: les forfaits

@Test
public void testLoadStore() {
    Store store = repository.findOne(1l);
    Assert.assertNotNull(store);
    Assert.assertEquals("EN Name", store.getName(Locale.ENGLISH));
    Assert.assertEquals("DE Name", store.getName(Locale.GERMAN));
}

Le problème, c'est que "Locale" ne peut être une propriété de LocalisedName sinon Hibernate se plaint d'une double colonne de cartographie. Voir le rapport de bug:

https://hibernate.atlassian.net/browse/HHH-5393

Ainsi, alors qu'il est possible d'écrire une méthode de recherche:

interface publique StoreRepository s'étend JpaRepository {

@Query(value = "from Store s join s.names n where n.name = ?1")
Store findByName(String name);

}

pour qui le test suivant passe

@Test
public void testLoadByName() {
    Store store = repository.findByName("EN Name");
    Assert.assertNotNull(store);
    Assert.assertEquals("EN Name", store.getName(Locale.ENGLISH));
    Assert.assertEquals("DE Name", store.getName(Locale.GERMAN));
}

aussi loin que je peux voir ce qui ne peut jamais prendre de paramètres Régionaux en compte que ce n'est pas une propriété de LocalizedName.

Non, bien sûr, il ne va pas au travail - vous ne jamais spécifier les paramètres Régionaux. Je l'ai essayé et j'obtiens: "valeur du Paramètre [Valeur] ne correspond pas au type attendu [com.test.LocalizedValue (n/a)];"
Voir mise à jour de réponse.

OriginalL'auteur Alan Hay

Vous devez vous connecter pour publier un commentaire.