JPA criterios de carga de consulta toda la tabla

Siento que esta es una pregunta tonta, pero no puedo encontrar la respuesta. Tengo una clase de la siguiente manera:

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name="DEMO_VARIABLES")
public class Variable implements Serializable
{
    private static final long serialVersionUID = -1734898766626582592L;

    @Id
    @SequenceGenerator(name="VARIABLE_ID_GENERATOR", sequenceName="DEMO_VARIABLE_ID_SEQ", allocationSize=1)
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="VARIABLE_ID_GENERATOR")
    @Column(name="VARIABLE_ID", unique=true, nullable=false, precision=22)
    private long variableId;

    @Column(name="VARIABLE_NAME", nullable=false, length=50)
    private String variableName;

    @Column(name="VARIABLE_VALUE", nullable=false, length=500)
    private String variableValue;

    public Variable()
    {

    }

    public long getVariableId()
    {
        return variableId;
    }

    public void setVariableId(long variableId)
    {
        this.variableId = variableId;
    }

    public String getVariableName()
    {
        return variableName;
    }

    public void setVariableName(String variableName)
    {
        this.variableName = variableName;
    }

    public String getVariableValue()
    {
        return variableValue;
    }

    public void setVariableValue(String variableValue)
    {
        this.variableValue = variableValue;
    }
}

Ahora quiero usar una consulta de criterios para cargar toda la tabla (es decir, «select * from variables»). Me gustaría utilizar una consulta de criterios más que el código de la consistencia que cualquier otra cosa. Tengo esta excepción, sin embargo:

java.lang.IllegalStateException: No criteria query roots were specified
    at org.hibernate.ejb.criteria.CriteriaQueryImpl.validate(CriteriaQueryImpl.java:303)
    at org.hibernate.ejb.criteria.CriteriaQueryCompiler.compile(CriteriaQueryCompiler.java:145)
    at org.hibernate.ejb.AbstractEntityManagerImpl.createQuery(AbstractEntityManagerImpl.java:437

La consulta que estoy usando es:

public List<Variable> loadAllVariables()
{
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Variable> query = builder.createQuery(Variable.class);

    return em.createQuery(query).getResultList();
} 

Sé que la excepción significa que quiere esta:

Root<Variable> variableRoot = query.from(Variable.class);

Pero sin un Predicado no veo cómo obtener el objeto Raíz en la consulta?

OriginalEl autor Greg | 2012-07-26

2 Kommentare

  1. 23

    No estoy seguro, ¿he entendido bien, pero si la meta es elegir buscar lista de todos los Variable entidades, luego el siguiente es el camino a seguir:

    public List<Variable> loadAllVariables() {
        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<Variable> query = builder.createQuery(Variable.class);
        Root<Variable> variableRoot = query.from(Variable.class);
        query.select(variableRoot);
    
        return em.createQuery(query).getResultList();
    } 

    Diferencia es que seleccione se utiliza. Todas las implementaciones no implícitamente el uso de la última llamada de de en lugar de seleccionar. En JPA 2.0 especificación de esto se dice como sigue:

    Aplicaciones portátiles deben utilizar seleccionar o multiselect método para
    especificar la consulta de la lista de selección. Las aplicaciones que no uso uno
    de estos métodos no será portable.

    Gracias que trabajó. Yo sólo estaba familiarizado con el uso de la consulta.donde() y dándole un Predicado basado en la Raíz. consulta.seleccione() era el eslabón perdido.

    OriginalEl autor Mikko Maunu

  2. 5

    De trabajo con la consulta y su raíz es muy simple:

    Primero llegar a la raíz de la manera que usted describe:

    Root<Variable> variableRoot = query.from(Variable.class);

    Después de esto, usted tiene que decirle a la consulta de qué se debe hacer con la raíz: seleccionar, en este caso.

    query.select(variableRoot);

    Después de eso, usted puede modificar la consulta con el query.where(...) función y tal.
    Cuando haya terminado, usted está listo para funcionar con su

    return em.createQuery(query).getResultList();

    Más info en el Oracle tutorial

    OriginalEl autor Humungus

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea