Erreur Hibernate - QuerySyntaxException: les utilisateurs ne sont pas mappés [à partir des utilisateurs]

J'essaye d'obtenir une liste de tous les utilisateurs de la table "utilisateurs" et j'obtiens l'erreur suivante:

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)

Voici le code que j'ai écrit pour ajouter / obtenir des utilisateurs:

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();
}

L'ajout d'utilisateurs fonctionne, mais lorsque j'utilise la fonction getUsers, j'obtiens ces erreurs.

Ceci est mon fichier de configuration d'hibernation:

<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>

et voici ma classe utilisateur:

@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;
    }
    ...    
}

Une idée pourquoi j'obtiens cette erreur?

Dans le HQL, vous devez utiliser le nom de la classe Java et le nom de la propriété du mappé @Entityau lieu du nom de la table et du nom de la colonne réels, donc le HQL doit être:

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

Mise à jour: Pour être plus précis, vous devez utiliser le nom d'entité configuré @Entitypour faire référence à la "table", qui par défaut est le nom non qualifié de la classe java mappée si vous ne le définissez pas explicitement.

(PS c'est @javax.persistence.Entitymais pas @org.hibernate.annotations.Entity)

Par exemple: votre nom de classe de bean est UserDetails

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

Vous ne donnez pas le nom de votre table sur le Db. vous donnez le nom de classe de bean .

Juste pour partager ma découverte. J'ai toujours la même erreur même si la requête ciblait le nom de classe correct. Plus tard, j'ai réalisé que j'importais la classe Entity à partir du mauvais package.

Le problème a été résolu après avoir changé la ligne d'importation de:

import org.hibernate.annotations.Entity;

à

import javax.persistence.Entity;

@TABLE(name = "TABLE_NAME")Annotation ajoutée et corrigée. Vérifiez vos annotations et votre fichier hibernate.cfg.xml. Voici l'exemple de fichier d'entité qui fonctionne:

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;
    }
}

Il est possible que vous ayez oublié d'ajouter le mappage pour l'entité créée dans la hibernate.cfg.xmlmême erreur.

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

Cela indique que hibernate ne connaît pas l' Userentité en tant qu '«utilisateurs».

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

L' @Tableannotation définit le nom de la table comme "Utilisateurs", mais le nom de l'entité est toujours appelé dans HQL "Utilisateur".

Pour changer les deux, vous devez définir le nom de l'entité:

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

Voir ma réponse ici pour plus d'informations: Erreur de table Hibernate non mappée

Assurez-vous également que la propriété suivante est définie dans la configuration de votre bean hibernate:

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

Cela indique à Spring et Hibernate où trouver vos classes de domaine annotées en tant qu'entités.

Certaines installations MySQL basées sur Linux nécessitent une sensibilité à la casse. Le contournement consiste à appliquer nativeQuery.

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

J'importais également la mauvaise entité, import org.hibernate.annotations.Entity; cela devrait être importéjavax.persistence.Entity;

Vérifiez également que vous avez ajouté la classe annotée en utilisant:

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

Cela m'a toujours fait perdre du temps lors de l'ajout d'une nouvelle table dans la base de données en utilisant Hibernate.

J'obtenais la même erreur pendant que Spring avec hibernate..J'utilisais "user" en minuscules dans ma createQuerydéclaration et ma classe était User..Alors changé en User dans ma requête et le problème a été résolu.

Requête avant:

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

Requête après:

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

J'ai eu ce problème lorsque j'ai remplacé l'ancienne bibliothèque hibernate-core par hibernate-core-5.2.12. Cependant, toute ma configuration était correcte. Et j'ai résolu ce problème en créant sessionfactory de cette façon:

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);

    }
}

J'espère que ça aide quelqu'un

Je recommande ce modèle:

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

    // Column definitions here

}

Dans votre requête, vous devez utiliser le nom de la classe (utilisateur) et non le nom de la table (utilisateurs) afin que votre requête soit "de l'utilisateur"

Vous devez saisir le même nom dans votre requête de sélection que votre entité ou classe (sensible à la casse). c'est-à-dire sélectionner l'utilisateur dans le nom de classe / nom d'entité utilisateur;

avec org.hibernate.hql.internal.ast.QuerySyntaxException: users is not mapped [from users], vous essayez de sélectionner dans le userstableau. Mais vous annotez votre classe avec @Table( name = "Users" ). Alors users, utilisez , ou Users.

Si vous utilisez une configuration xml, vous aurez besoin de quelque chose comme ce qui suit dans un fichier 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>