Errore di ibernazione - QuerySyntaxException: gli utenti non sono mappati [dagli utenti]

Sto cercando di ottenere un elenco di tutti gli utenti dalla tabella "utenti" e viene visualizzato il seguente errore:

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)

Questo è il codice che ho scritto per aggiungere / ottenere utenti:

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'aggiunta di utenti funziona, ma quando utilizzo la funzione getUsers ottengo questi errori.

Questo è il mio file di configurazione di ibernazione:

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

e questa è la mia classe utente:

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

Qualche idea sul perché ottengo questo errore?

In HQL, è necessario utilizzare il nome della classe java e il nome della proprietà del mappato @Entityanziché il nome effettivo della tabella e il nome della colonna, quindi l'HQL dovrebbe essere:

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

Aggiornamento: per essere più precisi, è necessario utilizzare il nome dell'entità configurato in @Entityper fare riferimento alla "tabella", il cui valore predefinito è il nome non qualificato della classe java mappata se non lo si imposta esplicitamente.

(PS Lo è @javax.persistence.Entityma non @org.hibernate.annotations.Entity)

Ad esempio: il nome della classe bean è UserDetails

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

Non si fornisce il nome della tabella sul Db. dai il nome della classe di bean .

Solo per condividere la mia scoperta. Ho ancora ricevuto lo stesso errore anche se la query aveva come target il nome di classe corretto. In seguito mi sono reso conto che stavo importando la classe Entity dal pacchetto sbagliato.

Il problema è stato risolto dopo aver modificato la riga di importazione da:

import org.hibernate.annotations.Entity;

per

import javax.persistence.Entity;

Aggiunta @TABLE(name = "TABLE_NAME")annotazione e correzione. Controlla le tue annotazioni e il file hibernate.cfg.xml. Questo è il file di entità di esempio che funziona:

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

È possibile che tu abbia dimenticato di aggiungere il mapping per l'Entità creata nello hibernate.cfg.xmlstesso errore.

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

Ciò indica che l'ibernazione non conosce l' Userentità come "utenti".

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

L' @Tableannotazione imposta il nome della tabella su "Utenti", ma il nome dell'entità viene ancora indicato in HQL come "Utente".

Per modificare entrambi, è necessario impostare il nome dell'entità:

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

Vedi la mia risposta qui per maggiori informazioni: Hibernate table non mapped error

Assicurarsi inoltre che la seguente proprietà sia impostata nella configurazione del bean di ibernazione:

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

Questo dice a Spring e Hibernate dove trovare le tue classi di dominio annotate come entità.

Alcune installazioni MySQL basate su Linux richiedono la distinzione tra maiuscole e minuscole. Aggirare è applicare nativeQuery.

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

Stavo anche importando l'Entità sbagliata import org.hibernate.annotations.Entity; Dovrebbe essere importatajavax.persistence.Entity;

Controlla anche di aver aggiunto la classe annotata usando:

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

Ciò ha sempre sprecato il mio tempo quando ho aggiunto una nuova tabella nel database usando Hibernate.

Stavo ottenendo lo stesso errore mentre Spring con l'ibernazione ... Stavo usando "user" in minuscolo nella mia createQueryaffermazione e la mia classe era User..Poi lo ho cambiato in User nella mia query e il problema è stato risolto.

Interrogazione prima:

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

Query dopo:

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

Ho riscontrato questo problema quando ho sostituito la vecchia libreria hibernate-core con hibernate-core-5.2.12. Comunque tutta la mia configurazione era ok. E ho risolto questo problema creando sessionfactory in questo modo:

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

    }
}

Spero che aiuti qualcuno

Consiglio questo modello:

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

    // Column definitions here

}

Nella tua query devi usare il nome della classe (Utente) e non il nome della tabella (utenti), quindi la tua query è "dall'utente"

È necessario digitare lo stesso nome nella query selezionata come entità o classe (case sensitive). cioè selezionare l'utente da className / Entity Name user;

con org.hibernate.hql.internal.ast.QuerySyntaxException: users is not mapped [from users], stai provando a selezionare dalla userstabella. Ma stai annotando la tua classe con @Table( name = "Users" ). Quindi utilizzare userso Users.

Se stai usando la configurazione xml, avrai bisogno di qualcosa di simile al seguente in un file 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>