Générateur de critères JPA avec plusieurs jointures

Question

J'ai du mal à créer une requête jpa qui utilise plusieurs tables. Je n'arrive pas à comprendre comment joindre les tables ensemble. c'est la requête que je suis en train de créer:

SELECT algm.m_l_i, algnsm.n_s_i 
    FROM algm, alg, algnsm, mal 
WHERE algm.l_g_i = alg.l_g_i 
    AND alg.l_g_t = 'xxx' 
    AND algnsm.l_g_i = algm.l_g_i 
    AND mal.c_l_i = algm.m_l_i 
    AND mal.p_l_i = 'yyy'; 

j'ai essayé plusieurs approches, d'utiliser l'opérateur de jointure à l'aide de l'opérateur où sur les touches. Je ne peux pas trouver assez d'informations sur les jointures sur le net pour aider beaucoup. Je suis coincé dès que je tente de rejoindre plus de 1 table de profondeur. quelques conseils ou astuces seraient vraiment utiles. grâce

CriteriaBuilder b = em.getCriteriaBuilder(); 
CriteriaQuery<Tuple> q = builder.createTupleQuery(); 
Root<MAL> malRoot = query.from(MAL.class); 
Root<ALGM> algmRoot = query.from(ALGM.class); 

// error 
algmRoot.join(ML_.mLI); 
// error 
malRoot.join(ML_.mLI); 

Predicate e1 = builder.equal(malRoot.get(MAL_.pL).get(ML_.mLI), "abc"); 
Predicate e2 = builder.equal(malRoot.get(MAL_.cL), algmRoot.get(ALGM_.mL)); 

query.where(builder.and(e1, e2)); 

query.select(builder.tuple(malRoot.get(MAL_.pL), malRoot.get(MAL_.cL), algmRoot.get(ALGM_.aLG).get(ALG_.lGT))); 

@Entity 
@Table(name = "M_A_L") 
public class MAL implements Serializable { 
    @EmbeddedId 
    protected MALPK malPK; 

    @Basic(optional = false) 
    @Column(name = "ENTRY_IND") 
    private String entryInd; 

    @JoinColumn(name = "P_L_I", referencedColumnName = "M_L_I", insertable = false, updatable = false) 
    @ManyToOne(optional = false) 
    private ML pL; 

    @JoinColumn(name = "C_L_I", referencedColumnName = "M_L_I", insertable = false, updatable = false) 
    @ManyToOne(optional = false) 
    private ML cL; 
... 
} 

@Entity 
@Table(name = "A_L_G_M") 
public class ALGM implements Serializable { 

    @EmbeddedId 
    protected ALGMPK algmPK; 

    @JoinColumn(name = "M_L_I", referencedColumnName = "M_L_I", insertable = false, updatable = false) 
    @ManyToOne(optional = false, fetch = FetchType.EAGER) 
    private ML mL; 

    @JoinColumn(name = "L_G_I", referencedColumnName = "L_G_I", insertable = false, updatable = false) 
    @ManyToOne(optional = false) 
    private ALG aLG; 
.... 
} 

public class ALGM_ { 
    public static volatile SingularAttribute<ALGM, ML> mL; 
    public static volatile SingularAttribute<ALGM, ALGMPK> aLGMPK; 
    public static volatile SingularAttribute<ALGM, ALG> aLG; 
} 

public class MAL_ { 
    public static volatile SingularAttribute<MAL, String> eI; 
    public static volatile SingularAttribute<MAL, MALPK> mALPK; 
    public static volatile SingularAttribute<MAL, ML> pL; 
    public static volatile SingularAttribute<MAL, ML> cL; 
} 

public class ALG_ { 
    public static volatile CollectionAttribute<ALG, MW> mWC; 
    public static volatile SingularAttribute<ALG, ALGCM> aLGCM; 
    public static volatile SingularAttribute<ALG, ALGAVM> aLGAVM; 
    public static volatile SingularAttribute<ALG, TR> tZ; 
    public static volatile CollectionAttribute<ALG, ALGM> aLGMC; 
    public static volatile SingularAttribute<ALG, String> d; 
    public static volatile SingularAttribute<ALG, String> lGT; 
    public static volatile SingularAttribute<ALG, String> lGI; 
    public static volatile SingularAttribute<ALG, ALGNSM> aLGNSM; 
    public static volatile SingularAttribute<ALG, ALGFVM> aLGFVM; 
    public static volatile SingularAttribute<ALG, ALGNAM> aLGNAM; 
} 

Answer 1

s'associe à la requête JPA se présenter comme suit:

pour créer une jointure de A à B:

Root<A> root .... 
CriteriaQuery<?> query ..... 
CriteriaBuilder builder..... 

Join<A, B> BTable = root.join(SingularAttribute<A, B>); 

ou

Join<A, B> BTable = root.join(A_.B); 

une fois que vous avez l'arbitre à bTable vous pouvez l'utiliser pour les variables de chemin.