L'interrogation relation ManyToMany avec Hibernate Critères

Je ne suis pas sûr de la façon de décrire ce problème, donc je pense que l'exemple est le meilleur moyen de poser ma question:

J'ai deux tables avec une relation manyToMany:

DriversLicence <-> LicenceClass

LicenceClass est des choses comme "Voiture", "Moto", et le "Support Rigide".

De l'utilisation d'Hibernate Critères, comment puis-je trouver toutes les licences qui ont à la fois "Voiture" et "Moto" LicenceClasses?

Mise à JOUR 12/11/2008
J'ai découvert que cela peut facilement être réalisé en utilisant un custom ResultTransformer. Toutefois, le problème est qu'un résultat transformateur est appliquée APRÈS que la requête renvoie ses résultats, il ne devient réellement une partie de la SQL. Donc je suppose que ma question est maintenant: "Pouvez-vous faire ce que j'ai d'abord décrit dans SQL - et est-il une Hibernate Critères analogique?"

OriginalL'auteur Daniel Alexiuc | 2008-11-05

  1. 6

    Voici comment j'ai finalement réalisé à l'aide de requêtes HQL:

    public List<DriversLicence> findDriversLicencesWith(List<LicenceClass> licenceClasses) {
    String hqlString = "select dl from DriversLicenceImpl dl where 1=1 ";
    for (int i = 0; i < licenceClasses.size(); i++) {
        hqlString += " and :licenceClass" + i + " = some elements(dl.licenceClasses)";
    }

    Query query = getSession().createQuery(hqlString);
    for (int i = 0; i < licenceClasses.size(); i++) {
        query.setParameter("licenceClass" + i, licenceClasses.get(i));
    }
    return query.list();
}

    Ou de l'utilisation d'Hibernate avec les Critères de sqlRestriction:

    for (LicenceClass licenceClass : licenceClasses) {               
    criteria.add(Restrictions.sqlRestriction("? = some(select " + LicenceClass.PRIMARY_KEY + " from " +
                    LICENCE_CLASS_JOIN_TABLE + "  where {alias}." +
                    DriversLicence.PRIMARY_KEY + " = " + DriversLicence.PRIMARY_KEY + ")",
                    licenceClass.getId(), Hibernate.LONG));
}

    LICENCE_CLASS_JOIN_TABLE est le nom de la table que hibernate génère à l'appui de la plusieurs-à-plusieurs relation entre driversLicence et LicenceClass.

    OriginalL'auteur

  2. 0

    Vous pouvez toujours utiliser la notation point à travailler à travers les relations. Par exemple, en supposant que vous avez un DriversLicence.licenceClass propriété et LicenceClass.type de propriété:

    session.createCriteria(DriversLicence.class)
   .add(Expression.or(
     Expression.eq("licenceClass.type", "Car"),
     Expression.eq("licenceClass.type", "Motorbike")
   )
).list();

    Personnellement, je serais tout simplement éviter d'utiliser des critères dans ce cas, car il n'est pas une requête dynamique, mais au lieu d'utiliser:

    session.createQuery("from DriversLicence where licenceClass.type in (:types)")
  .setParameterList("types", myListOfTypes)
  .list();
    Je ne pense pas que cela va fonctionner. Je veux trouver toutes les licences qui ont "Voiture" et "Moto" LicenceClasses. Pas .
    Ahh... bon point. Bien que pas le plus efficace, vous pouvez: sélectionner dl de DriversLicence dl rejoindre d.licenceType lt où "Voiture" = de certains éléments(lt.type) et "Moto" = de certains éléments(lt.type), Cela peut aussi être modifié pour utiliser des critères (de caractères!)
    Oui, c'est le genre de chose que je veux - mais comment faites-vous avec ces critères? Poster une autre réponse si vous le souhaitez!

    OriginalL'auteur Nick

  3. 0

    J'ai eu un problème similaire, mais fixé à l'aide de requêtes HQL, j'ai une classe "Entreprise" qui est liée à la catégorie "Utilisateur" et aussi liées à la classe "Rôle", ils foin une relation plusieurs-à-plusieurs, quand j'ai besoin de toutes les entreprises liées à un utilisateur spécifique, je ne les suivants;

    Select e from Enterprise As e inner join e.Users As u inner join u.Roles As r 
Where u.UserCode=?

    Je suppose que dans votre cas, vous devriez faire quelque chose comme;

    Select dl from LicenceClass As l inner join l.DriversLicences As dl
Where 
l.LicenseClass.Name = ? OR 
l.LicenseClass.Name=? OR 
l.LicenseClass.Name=?

    Espère que cela aide.

    OriginalL'auteur Nelson Miranda

  4. 0

    Une autre option est de la chaîne des jointures (une jointure pour chaque LicenseClass). J'ai utilisé les critères de constructeur et de prédicats comme ce

     List<Predicate> predicates = new ArrayList<>();
 for(Integer lcId : licenceClassIdList) {
     SetJoin<DriversLicence, LicenceClass> dlClasses = dlRoot.join(DriversLicence_.licenceClasses);
     predicates.add(builder.equal(dlClasses.get(LicenseClass_.id), lcId));
 }
 Predicate predicate = builder.and(predicates.toArray(new Predicate[predicates.size()]));

    Avis dlRoot est un objet de la classe Racine et vous pouvez l'obtenir à partir d'CriteriaQuery classe. Entraîné prédicat est ce que vous cherchez...

    OriginalL'auteur Mara B

  5. -1

    "Je ne pense pas que cela va fonctionner. Je veux trouver toutes les licences qui ont les deux "Voiture" et "Moto" '

    Expression Utilisateur.et(....) au lieu d'Expression.ou(....) dans l'extrait de code fourni par Nick

    Nan c'est faux aussi. Je commence à penser que cette apparemment simple cas d'utilisation est tout simplement pas possible dans hibernate - quelqu'un pourrait-il confirmer et expliquer pourquoi?

    OriginalL'auteur Adi