Error de hibernación: QuerySyntaxException: los usuarios no están asignados [de los usuarios]

Estoy tratando de obtener una lista de todos los usuarios de la tabla "usuarios" y aparece el siguiente error:

org.hibernate.hql.internal.ast.QuerySyntaxException: users is not mapped [from users]
org.hibernate.hql.internal.ast.util.SessionFactoryHelper.requireClassPersister(SessionFactoryHelper.java:180)
org.hibernate.hql.internal.ast.tree.FromElementFactory.addFromElement(FromElementFactory.java:110)
org.hibernate.hql.internal.ast.tree.FromClause.addFromElement(FromClause.java:93)

Este es el código que escribí para agregar / obtener usuarios:

public List<User> getUsers() {
    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();
    List<User> result = (List<User>) session.createQuery("from users").list();
    session.getTransaction().commit();
    return result;
}

public void addUser(User user) {
    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();
    session.save(user);
    session.getTransaction().commit();
}

public void addUser(List<User> users) {
    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();
    for (User user : users) {
        session.save(user);
    }
    session.getTransaction().commit();
}

Agregar usuarios funciona, pero cuando uso la función getUsers obtengo estos errores.

Este es mi archivo de configuración de hibernación:

<hibernate-configuration>
<session-factory>
    <property name="connection.url">jdbc:mysql://localhost:3306/test</property>
    <property name="connection.username">root</property>
    <property name="connection.password">root</property>
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="hibernate.default_schema">test</property>
    <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

    <property name="show_sql">true</property>

    <property name="format_sql">true</property>
    <property name="hbm2ddl.auto">create-drop</property>

    <!-- JDBC connection pool (use the built-in) -->
    <property name="connection.pool_size">1</property>
    <property name="current_session_context_class">thread</property>

    <!-- Mapping files will go here.... -->

    <mapping class="model.Company" />
    <mapping class="model.Conference" />
    <mapping class="model.ConferencesParticipants" />
    <mapping class="model.ConferenceParticipantStatus" />
    <mapping class="model.ConferencesUsers" />
    <mapping class="model.Location" />
    <mapping class="model.User" />

</session-factory>

y esta es mi clase de usuario:

@Entity
@Table( name = "Users" )
public class User implements Serializable{

    private long userID;
    private int pasportID;
    private Company company; 
    private String name;
    private String email;
    private String phone1;
    private String phone2;
    private String password; //may be null/empty , will be kept hashed
    private boolean isAdmin;
    private Date lastLogin;

    User() {} //not public on purpose!

    public User(int countryID, Company company, String name, String email,
            String phone1, String phone2, String password, boolean isAdmin) {
        this.pasportID = countryID;
        this.company = company;
        this.name = name;
        this.email = email;
        this.phone1 = phone1;
        this.phone2 = phone2;
        this.password = password;
        this.isAdmin = isAdmin;
    }

    @Id
    @GeneratedValue(generator="increment")
    @GenericGenerator(name="increment", strategy = "increment")
    public long getUserID() {
        return userID;
    }
    public void setUserID(long userID) {
        this.userID = userID;
    }
    ...    
}

¿Alguna idea de por qué me sale este error?

En el HQL, debe usar el nombre de clase de Java y el nombre de propiedad del mapeado en @Entitylugar del nombre real de la tabla y el nombre de la columna, por lo que el HQL debería ser:

List<User> result = session.createQuery("from User", User.class).getResultList();

Actualización: para ser más precisos, debe usar el nombre de la entidad configurado @Entitypara referirse a la "tabla", que por defecto es el nombre no calificado de la clase de Java asignada si no lo establece explícitamente.

(PD es @javax.persistence.Entitypero no @org.hibernate.annotations.Entity)

Por ejemplo: su nombre de clase de bean es UserDetails

Query query = entityManager. createQuery("Select UserName from **UserDetails** "); 

No da el nombre de su tabla en el Db. le das el nombre de clase de bean .

Solo para compartir mi hallazgo. Todavía recibí el mismo error incluso si la consulta estaba dirigida al nombre de clase correcto. Más tarde me di cuenta de que estaba importando la clase Entity del paquete incorrecto.

El problema se resolvió después de cambiar la línea de importación de:

import org.hibernate.annotations.Entity;

a

import javax.persistence.Entity;

@TABLE(name = "TABLE_NAME")Anotación agregada y corregida. Verifique sus anotaciones y el archivo hibernate.cfg.xml. Este es el archivo de entidad de muestra que funciona:

import javax.persistence.*;

@Entity
@Table(name = "VENDOR")
public class Vendor {

    //~ --- [INSTANCE FIELDS] ------------------------------------------------------------------------------------------
    private int    id;
    private String name;

    //~ --- [METHODS] --------------------------------------------------------------------------------------------------
    @Override
    public boolean equals(final Object o) {    
        if (this == o) {
            return true;
        }

        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        final Vendor vendor = (Vendor) o;

        if (id != vendor.id) {
            return false;
        }

        if (name != null ? !name.equals(vendor.name) : vendor.name != null) {
            return false;
        }

        return true;
    }

    //~ ----------------------------------------------------------------------------------------------------------------
    @Column(name = "ID")
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    public int getId() {
        return id;
    }

    @Basic
    @Column(name = "NAME")
    public String getName() {

        return name;
    }

    public void setId(final int id) {
        this.id = id;
    }

    public void setName(final String name) {    
        this.name = name;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

Existe la posibilidad de que haya olvidado agregar la asignación para la Entidad creada en el hibernate.cfg.xmlmismo error.

org.hibernate.hql.internal.ast.QuerySyntaxException: users is not mapped [from users]

Esto indica que hibernate no conoce a la Userentidad como "usuarios".

@javax.persistence.Entity
@javax.persistence.Table(name = "Users")
public class User {

La @Tableanotación establece que el nombre de la tabla sea ​​"Usuarios", pero el nombre de la entidad todavía se conoce en HQL como "Usuario".

Para cambiar ambos, debe establecer el nombre de la entidad:

// this sets the name of the table and the name of the entity
@javax.persistence.Entity(name = "Users")
public class User implements Serializable{

Vea mi respuesta aquí para obtener más información: error de la tabla de hibernación no asignada

Asegúrese también de que la siguiente propiedad esté establecida en su configuración de bean de hibernación:

<property name="packagesToScan" value="yourpackage" />

Esto le dice a Spring e Hibernate dónde encontrar sus clases de dominio anotadas como entidades.

Algunas instalaciones de MySQL basadas en Linux requieren mayúsculas y minúsculas. Evitar es aplicar nativeQuery.

@Query(value = 'select ID, CLUMN2, CLUMN3 FROM VENDOR c where c.ID = :ID', nativeQuery = true)

También estaba importando la entidad incorrecta. import org.hibernate.annotations.Entity; Debería ser importarjavax.persistence.Entity;

También verifique que haya agregado la clase anotada usando:

new Configuration().configure("configuration file path").addAnnotatedClass(User.class)

Eso siempre desperdició mi tiempo al agregar una nueva tabla en la base de datos usando Hibernate.

Recibía el mismo error mientras Spring con hibernación ... Estaba usando "usuario" en minúsculas en mi createQuerydeclaración y mi clase era Usuario ... Así que lo cambié a Usuario en mi consulta y el problema se resolvió.

Consulta antes:

Query query= em.createQuery("select u from user u where u.username=:usr AND u.password=:pass",User.class);

Consulta después de:

Query query= em.createQuery("select u from User u where u.username=:usr AND u.password=:pass",User.class);

Recibí este problema cuando reemplacé la antigua biblioteca de hibernate-core con hibernate-core-5.2.12. Sin embargo, toda mi configuración estaba bien. Y solucioné este problema creando sessionfactory de esta manera:

private static SessionFactory buildsSessionFactory() {
    try {
        if (sessionFactory == null) {
            StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder()
                    .configure("/hibernate.cfg.xml").build();
            Metadata metaData = new MetadataSources(standardRegistry)
                    .getMetadataBuilder().build();
            sessionFactory = metaData.getSessionFactoryBuilder().build();
        }
        return sessionFactory;
    } catch (Throwable th) {

        System.err.println("Enitial SessionFactory creation failed" + th);

        throw new ExceptionInInitializerError(th);

    }
}

Espero que ayude a alguien

Recomiendo este patrón:

@Entity(name = User.PERSISTANCE_NAME)
@Table(name = User.PERSISTANCE_NAME )
public class User {    
    static final String PERSISTANCE_NAME = "USER";

    // Column definitions here

}

En su consulta, debe usar el nombre de la clase (Usuario) no el nombre de la tabla (usuarios) para que su consulta sea "del Usuario"

Debe escribir el mismo nombre en su consulta de selección como su entidad o clase (distingue entre mayúsculas y minúsculas). es decir, seleccionar usuario del usuario className / Entity Name;

con org.hibernate.hql.internal.ast.QuerySyntaxException: users is not mapped [from users], está intentando seleccionar de la userstabla. Pero estás anotando tu clase con @Table( name = "Users" ). Entonces use users, o Users.

Si está utilizando la configuración xml, necesitará algo como lo siguiente en un archivo applicationContext.xml:

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" lazy-init="default" autowire="default" dependency-check="default">
<property name="dataSource">
  <ref bean="dataSource" />
</property>
<property name="annotatedClasses">
  <list>
    <value>org.browsexml.timesheetjob.model.PositionCode</value>
  </list>