Hibernate critères de requête pour la Collecte de la Table?

J'ai Entité suivante

@Entity
@Table(name = "rule")
public class Rule implements Serializable {

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

    @ElementCollection(targetClass = Action.class)


     @CollectionTable(name = "rule_action", joinColumns = @JoinColumn(name = "rule_id"))
        @Enumerated(value = EnumType.STRING)
        @Column(name = "action")
        private Set<Action> actions;

//After editing as per jbrookover's suggestion adding a new mapping
       @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
       @JoinColumn(name = "rule_id")
       private Set<RuleAction> ruleActions;


    }

Suite à mon Action est

public enum Action {
    PHONE, EMAIL, POSTAL,PHONE_OR_EMAIL, SMS;
}

Je veux extraire une Liste de règle, ayant ensemble particulier d'actions
Je suis en train d'essayer cette

 DetachedCriteria criteria = DetachedCriteria.forClass(Rule.class,"rule");
 criteria = criteria.createAlias("rule.actions", "action");
 criteria.add(Restrictions.in("action.name",actionSet));
 return getHibernateTemplate().findByCriteria(criteria);

Mais se
org.mise en veille prolongée.MappingException: la collection n'était pas une association: exception..

MODIFIER
Ainsi, après les conseils de jbrookover j'ai essayé d'aller pour une classe wrapper pour l'Action nommée RuleAction et a été en mesure de eshtablish la relation oneToMany, Aussi j'ai modifié la requête comme suit

    Set<Action> act = new HashSet<Action>();
    act.add(Action.EMAIL);
    act.add(Action.POSTAL);

    DetachedCriteria criteria = DetachedCriteria.forClass(Rule.class);
    criteria.add(Restrictions.eq(SUPPORT_LANG, Language.valueOf("EN")))
            .createCriteria("ruleActions").add(Restrictions.in("action",act));
    return getHibernateTemplate().findByCriteria(criteria);

Mais c'est le retour de moi tout le règle avec e-MAIL ou POSTALE, mais ce que je veux, c'est tout, l'état d'avoir des emails et POSTALES à la fois Merci de m'aider dans la modification de la requête.

OriginalL'auteur Anupam Gupta | 2011-10-07

hibernate hibernate-criteria

6

Désolé, ce que vous essayez de le faire, précisément, n'est pas pris en charge en mode veille prolongée. Voir cette FAQ:

http://community.jboss.org/wiki/HibernateFAQ-AdvancedProblems#Im_getting_orghibernateMappingException_collection_was_not_an_association_when_I_try_to_join_a_collection_of_components_with_Criteria_queries

Moi aussi, j'ai été très mécontent de cette. Comme vous pouvez le voir, cependant, ils ont essayé de corriger un ont été incapables de le faire et l'ont mis sur la communauté pour faire face avec elle. Vous avez plusieurs options:
1. Utilisation HQL pour exécuter la requête.
2. De ré-écrire votre collection de l'association comme une véritable entité de la classe avec un seul champ Enum.
Vous pouvez faire quelque chose comme ceci:
```
 @Entity
 public class ActionWrapper {

      public Action action;
 }
```
Ensuite, mettez à jour vos associations et de la requête en conséquence, de sorte que Rule a un Set<ActionWrapper>. Il existe d'autres solutions de contournement, mais vous ne pouvez pas utiliser Criteria et @ElementCollection ensemble.

Mise à jour

Dans le but de restreindre la requête en outre, pour s'assurer que vous obtenez des Règles qui répondent à ces DEUX actions, vous devez exécuter la sous-requête et de faire un concert - " et " - de la correspondance des valeurs. Quelque chose comme ceci devrait fonctionner:
```
 Criteria subCriteria = criteria.createCriteria("ruleActions");
 Disjunction and = Restrictions.conjunction();
 for (Action a : act)
    and.add(Restrictions.eq("action", a)
 subCriteria.add(and);
```
À la fin, vous pouvez trouver les résultats. Ce qui est commun et peut être éliminé par l'ajout de cette:
```
 criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
```
Je ne peux pas parler pour l'efficacité de ce code - HQL peut-être mieux dans le long terme. Cependant, j'ai fait quelque chose de similaire dans d'autres projets et n'avons pas rencontré de problèmes.

salut jbrookover ..merci!! Comme par ur suggestion, je suis en train de passer par une Classe Wrapper. et avez modifié votre réponse par ce que je fais ..de sorte qu'il peut aider d'autres qui font face à un même problème
Mis à jour pour inclure la restreinte de la requête.
merci @jbrookover que, désormais, j'ai utilisé les requêtes Hql..et assez occupés pour l'utilisation de votre solution va bientôt changer votre suggestion et sera également mise à jour ici, dans l'affirmative, de sorte qu'il peut être utile pour les autres

OriginalL'auteur jbrookover

Une autre solution sans emballage de votre enums et à l'aide de ResultTransformers est-ce:

        @ElementCollection(fetch = FetchType.EAGER)
        @Enumerated(value = EnumType.STRING)
        @Column(name = " action")
        @JoinTable(name = "rule_action", joinColumns = { @JoinColumn(name = "rule_id") })
        private Set<Action> actions;

Requête:

DetachedCriteria criteria = DetachedCriteria.forClass(Rule.class,"rule");
criteria = criteria.createAlias("rule.actions", "action");
criteria.add(Restrictions.in("action." + CollectionPropertyNames.COLLECTION_ELEMENTS, actionSet));
return getHibernateTemplate().findByCriteria(criteria);

C'est ce qui a fonctionné pour moi avec Hibernate 4.1.6.Final. Je l'ai trouvé ici.

merci, cela fonctionne très bien pour moi!

OriginalL'auteur schnatterer

1

Les critères de requête a l'air bien. Supposons que nous avons des tables:
```
rule(id, name,...)
action(id, name,..)
rule_action(id, rule_id, action_id,...) -- (or rule_id+action_id as  a composite pkey)
```
La correspondance doit être comme suit:
```
public class Rule {
   ...
   @ManyToMany(mappedBy = "rule")
   private Set<Action> actions;
   ...
}

public class Action {
   ...
   @JoinTable(
      name="rule_action",
      joinColumns={@JoinColumn(name="action_id")},
      inverseJoinColumns={@JoinColumn(name="rule_id")}
   )
   private Set<Rule> rules;
   ...
}
```
De cette façon vos critères de requête devrait fonctionner.

BONJOUR pouvez vous s'il vous plaît laissez-moi savoir comment écrire un hibernate critères de la requête pour le cas ci-dessus, je veux ajouter des critères de telle manière que ma requête doit retourner toutes les règles ayant une action A & D (de série d'actions {A,B,C,D,E})
Salut, je suis désolé, apparemment, je suis mauvais en lisant attentivement les questions. La réponse initiale a été totalement trompeuse, donc j'ai complètement réécrit. Prendre un coup d'oeil.
en fait, je suis un peu préoccupé par la modification de la cartographie depuis le code actuel est à l'aide de CollectionTable. Et le mappage actuel est largement utilisé, donc je veux juste être sûr que je ne suis pas casser le code existant.. est-ce que la modification de la cartographie comme celle que vous avez dit à aura un effet sur le système existant?
de plus, je suis désolé de ne pas mentionner que mon Action est de type Enum .. j'ai mis à jour la question de l'Action de l'entité. Et ont commencé Bounty de 50 points.

OriginalL'auteur forker

Vous devez vous connecter pour publier un commentaire.