Fehler im Ruhezustand - QuerySyntaxException: Benutzer sind nicht zugeordnet [von Benutzern]

Ich versuche, eine Liste aller Benutzer aus der Tabelle "Benutzer" abzurufen, und erhalte die folgende Fehlermeldung:

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)

Dies ist der Code, den ich geschrieben habe, um Benutzer hinzuzufügen / zu erhalten:

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

Das Hinzufügen von Benutzern funktioniert, aber wenn ich die Funktion getUsers verwende, wird dieser Fehler angezeigt.

Dies ist meine Konfigurationsdatei für den Ruhezustand:

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

und das ist meine Benutzerklasse:

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

Irgendeine Idee, warum ich diesen Fehler bekomme?

In der HQL sollten Sie den Java-Klassennamen und den Eigenschaftsnamen der zugeordneten Datei @Entityanstelle des tatsächlichen Tabellennamens und Spaltennamens verwenden. Die HQL sollte also wie folgt lauten:

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

Update: Um genauer zu sein, sollten Sie den in konfigurierten Entitätsnamen verwenden @Entity, um auf die "Tabelle" zu verweisen, die standardmäßig den nicht qualifizierten Namen der zugeordneten Java-Klasse verwendet, wenn Sie ihn nicht explizit festlegen.

(PS ist es @javax.persistence.Entityaber nicht @org.hibernate.annotations.Entity)

Beispiel: Ihr Bean-Klassenname lautet UserDetails

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

Sie geben Ihren Tabellennamen nicht in der Datenbank an. Sie geben den Klassennamen der Bohne an .

Nur um meine Erkenntnisse zu teilen. Ich habe immer noch den gleichen Fehler erhalten, auch wenn die Abfrage auf den richtigen Klassennamen abzielte. Später wurde mir klar, dass ich die Entity-Klasse aus dem falschen Paket importierte.

Das Problem wurde behoben, nachdem ich die Importzeile von geändert habe:

import org.hibernate.annotations.Entity;

zu

import javax.persistence.Entity;

@TABLE(name = "TABLE_NAME")Anmerkung hinzugefügt und behoben. Überprüfen Sie Ihre Anmerkungen und die Datei hibernate.cfg.xml. Dies ist die Beispielentitätsdatei, die funktioniert:

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

Möglicherweise haben Sie vergessen, die Zuordnung für die erstellte Entität zu hibernate.cfg.xmldemselben Fehler hinzuzufügen .

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

Dies zeigt an, dass der Ruhezustand die UserEntität nicht als "Benutzer" kennt .

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

In der @TableAnmerkung wird der Tabellenname auf "Benutzer" festgelegt, der Entitätsname wird in HQL jedoch weiterhin als "Benutzer" bezeichnet.

Um beide zu ändern, sollten Sie den Namen der Entität festlegen:

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

Weitere Informationen finden Sie in meiner Antwort hier: Fehler im Ruhezustand der Tabelle nicht zugeordnet

Stellen Sie außerdem sicher, dass die folgende Eigenschaft in Ihrer Hibernate-Bean-Konfiguration festgelegt ist:

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

Dies teilt Spring und Hibernate mit, wo sich Ihre als Entitäten kommentierten Domänenklassen befinden.

Bei einigen Linux-basierten MySQL-Installationen muss zwischen Groß- und Kleinschreibung unterschieden werden. Umgehen ist zu bewerben nativeQuery.

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

Ich habe auch die falsche Entität importiert. import org.hibernate.annotations.Entity; Es sollte importiert werdenjavax.persistence.Entity;

Überprüfen Sie außerdem, ob Sie die mit Anmerkungen versehene Klasse hinzugefügt haben, indem Sie Folgendes verwenden:

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

Das hat immer meine Zeit verschwendet, wenn ich mit Hibernate eine neue Tabelle in die Datenbank aufgenommen habe.

Ich habe den gleichen Fehler erhalten, während Spring mit Ruhezustand. Ich habe "Benutzer" in meiner createQueryAnweisung in Kleinbuchstaben verwendet und meine Klasse war Benutzer. Also habe ich ihn in meiner Abfrage in Benutzer geändert und das Problem wurde behoben.

Abfrage vor:

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

Abfrage nach:

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

Ich habe dieses Problem erhalten, als ich die alte Hibernate-Core-Bibliothek durch Hibernate-Core-5.2.12 ersetzt habe. Meine gesamte Konfiguration war jedoch in Ordnung. Und ich habe dieses Problem behoben, indem ich sessionfactory folgendermaßen erstellt habe:

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

    }
}

Hoffe es hilft jemandem

Ich empfehle dieses Muster:

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

    // Column definitions here

}

In Ihrer Abfrage müssen Sie den Klassennamen (Benutzer) und nicht den Tabellennamen (Benutzer) verwenden, damit Ihre Abfrage "vom Benutzer" lautet.

Sie müssen in Ihrer Auswahlabfrage denselben Namen wie Ihre Entität oder Klasse eingeben (Groß- und Kleinschreibung beachten). dh Benutzer aus Klassenname / Entitätsname auswählen Benutzer;

Mit org.hibernate.hql.internal.ast.QuerySyntaxException: users is not mapped [from users]versuchen Sie, aus der usersTabelle auszuwählen . Aber Sie kommentieren Ihre Klasse mit @Table( name = "Users" ). Also entweder verwenden usersoder Users.

Wenn Sie die XML-Konfiguration verwenden, benötigen Sie in einer applicationContext.xml-Datei Folgendes:

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