Tengo 3 tablas:

A                              AB                        B
-------------                  ------------              ---------------
a1                              a1,b1                    b1

AB es una tabla de transición entre la a y la B

Con esto, mis clases no tienen la composición dentro de estas dos clases de uno a otro. Pero quiero saber que , con una Consulta JPQL, si cualquiera de los que existen registros para mi elemento de Una tabla en AB tabla. Solo número o un valor booleano es lo que necesito.

Porque AB es una tabla de transición, no hay objeto para el modelo y quiero saber si puedo hacer esto con una Consulta @en mi Repositorio de objetos.

No estoy seguro de jpql sin objeto entidad. ¿por qué no SQL ?
Sql puede hacer esto fácilmente, pero quiero conservar la coherencia(para usar sólo JPA) en mi proyecto. Pero, por supuesto, si no hay manera de hacerlo, voy a elegir SQL

OriginalEl autor Neron | 2013-01-08

3 Comentarios

  1. 4

    Yo sugiero utilizar Nativo método de consulta en lugar de JPQL (JPA admite Nativas de la consulta). Supongamos Una tabla de atención al Cliente y la tabla B es un Producto y AB es una Venta. Esta es la consulta para obtener la lista de productos que son ordenados por un cliente.

    entityManager.createNativeQuery("SELECT PRODUCT_ID FROM 
                                         SALE WHERE CUSTOMER_ID = 'C_123'");
    corrección: creo que te refieres a usar un Nativo de la consulta (que yo.e SQL) en LUGAR DE JPQL (poner “Nativo consulta JPQL”, mientras que JPQL es JPA propio lenguaje de consulta).
    gracias. respuesta actualizada ahora.
    Que trabajado. gracias

    OriginalEl autor vels4j

  2. 5

    el AB tabla debe ser el modelo de una entidad para ser consultados en JPQL. Por lo que debe de modelo como este
    una entidad de clase o asociación, en su a y /o B de la entidad.

    parece que lo. Gracias de todos modos

    OriginalEl autor mojoo-de

  3. 2

    Realidad, la respuesta a esta situación es más fácil que usted podría pensar. Es una simple cuestión de usar la herramienta correcta para el trabajo correcto. JPA no fue diseñado para la implementación complicado consultas SQL, que es lo que SQL es para! Por lo que necesita una manera de conseguir JPA para acceder a un nivel de producción de la consulta SQL;

    em.createNativeQuery

    Así que en tu caso lo que quieres hacer es acceder a la AB tabla buscando sólo el campo id. Una vez que haya recuperado su consulta, tome su id de campo y buscar el objeto de Java utilizando el identificador de campo. Es un segundo de búsqueda de la verdad, pero trivial por el estándar SQL.

    Supongamos que usted está buscando Un objeto basado en el número de veces que un objeto B de referencias. Digamos que usted quiere un semi-complicado (pero típico) consulta SQL a grupo tipo a objetos basado en el número de B objetos y en orden descendente. Este sería un típico popularidad consulta que usted puede ser que desee implementar según los requisitos del proyecto.

    Su consulta SQL nativa sería como tales:

    select a_id as id from AB group by a_id order by count(*) desc;

    Ahora lo que quiero hacer es decirle a JPA esperar la lista de identificación de regresar en una forma que JPA puede aceptar. Usted necesidad de poner juntos un extra de entidad JPA. Uno que nunca va a ser utilizado en el modo normal de JPA. Pero JPA necesita una forma para obtener la consulta de los objetos de nuevo a usted. Te iba a poner juntos una entidad para esta consulta de búsqueda como tal;

    @Entity
    public class IdSearch {
    
        @Id
        @Column
        Long id;
    
        public Long getId() {
                return id;
        }
    
        public void setId(Long id) {
                this.id = id;
        }
    
    }

    Ahora que aplicar un poco de código para traer las dos tecnologías juntas;

        @SuppressWarnings("unchecked")
        public List<IdSearch> findMostPopularA() {
                return em.createNativeQuery("select a_id as id from AB group by a_id 
                order by count(*) desc", IdSearch.class).getResultList();
        }

    Allí, eso es todo lo que tienes que hacer para conseguir JPA para obtener su consulta completado con éxito. Para acceder a los objetos de Un sólo de referencia cruzada en la lista usando el tradicional JPA enfoque, como tales;

    List<IdSearch> list = producer.getMostPopularA();
    Iterator<IdSearch> it = list.iterator();
    while ( it.hasNext() ) {
        IdSearch a = it.next();
        A object = em.find(A.class,a.getId());
        //your in business!

    Todavía, un poco más de refinamiento de lo anterior se puede simplificar las cosas un poco más allá de la realidad dada las muchas funciones de SQL de la estructura de diseño. Un poco más complicado de consultas SQL será aún más directa JPA interfaz de datos reales;

        @SuppressWarnings("unchecked")
        public List<A> findMostPopularA() {
                return em.createNativeQuery("select * from A, AB 
                where A.id = AB.a_id 
                group by a_id 
                order by count(*) desc", A.class).getResultList();
        }

    Esto elimina la necesidad de un interm IdSearch mesa!!!

    List<A> list = producer.getMostPopularA();
    Iterator<A> it = list.iterator();
    while ( it.hasNext() ) {
        A a = it.next();
        //your in business!

    Lo que puede no estar claro tot el ojo desnudo es la maravillosa forma simplificada JPA le permite hacer uso de complicadas estructuras de SQL dentro de la JPA de la interfaz. Imagínese si usted es un SQL de la siguiente manera;

    SELECT array_agg(players), player_teams
    FROM (
      SELECT DISTINCT t1.t1player AS players, t1.player_teams
      FROM (
        SELECT
          p.playerid AS t1id,
          concat(p.playerid,':', p.playername, ' ') AS t1player,
          array_agg(pl.teamid ORDER BY pl.teamid) AS player_teams
        FROM player p
        LEFT JOIN plays pl ON p.playerid = pl.playerid
        GROUP BY p.playerid, p.playername
      ) t1
    INNER JOIN (
      SELECT
        p.playerid AS t2id,
        array_agg(pl.teamid ORDER BY pl.teamid) AS player_teams
      FROM player p
      LEFT JOIN plays pl ON p.playerid = pl.playerid
      GROUP BY p.playerid, p.playername
    ) t2 ON t1.player_teams=t2.player_teams AND t1.t1id <> t2.t2id
    ) innerQuery
    GROUP BY player_teams

    El punto es que con createNativeQuery interfaz, usted todavía puede recuperar, precisamente, los datos que usted está buscando y directamente en el objeto deseado para el acceso fácil de Java.

        @SuppressWarnings("unchecked")
        public List<A> findMostPopularA() {
                return em.createNativeQuery("SELECT array_agg(players), player_teams
                FROM (
                      SELECT DISTINCT t1.t1player AS players, t1.player_teams
                      FROM (
                        SELECT
                          p.playerid AS t1id,
                          concat(p.playerid,':', p.playername, ' ') AS t1player,
                          array_agg(pl.teamid ORDER BY pl.teamid) AS player_teams
                        FROM player p
                        LEFT JOIN plays pl ON p.playerid = pl.playerid
                        GROUP BY p.playerid, p.playername
                      ) t1
                    INNER JOIN (
                      SELECT
                        p.playerid AS t2id,
                        array_agg(pl.teamid ORDER BY pl.teamid) AS player_teams
                      FROM player p
                      LEFT JOIN plays pl ON p.playerid = pl.playerid
                      GROUP BY p.playerid, p.playername
                    ) t2 ON t1.player_teams=t2.player_teams AND t1.t1id <> t2.t2id
                    ) innerQuery
                    GROUP BY player_teams
                ", A.class).getResultList();
        }

    Saludos,

    Perry

    [email protected]

    OriginalEl autor Perry

Dejar respuesta

Please enter your comment!
Please enter your name here