org.internate 를 선택합니다.hql.internal.ast 입니다.QuerySyntaxException: 테이블이 매핑되지 않았습니다.

org.internate 를 선택합니다.hql.internal.ast 입니다.QuerySyntaxException: 테이블이 매핑되지 않았습니다.

IDE NetBeans 8.0Beta를 탑재한 웹 어플리케이션 Hibernate 4.3.5 + Derby 데이터베이스 10.10.1.1 + Glassfish 4.0이 있습니다.

다음 예외가 있습니다.

Caused by: org.hibernate.hql.internal.ast.QuerySyntaxException: CUSTOMERV is not mapped
at org.hibernate.hql.internal.ast.util.SessionFactoryHelper.requireClassPersister(SessionFactoryHelper.java:189)
at org.hibernate.hql.internal.ast.tree.FromElementFactory.addFromElement(FromElementFactory.java:109)
at org.hibernate.hql.internal.ast.tree.FromClause.addFromElement(FromClause.java:95)
at org.hibernate.hql.internal.ast.HqlSqlWalker.createFromElement(HqlSqlWalker.java:331)
at org.hibernate.hql.internal.antlr.HqlSqlBaseWalker.fromElement(HqlSqlBaseWalker.java:3633)
at org.hibernate.hql.internal.antlr.HqlSqlBaseWalker.fromElementList(HqlSqlBaseWalker.java:3522)
at org.hibernate.hql.internal.antlr.HqlSqlBaseWalker.fromClause(HqlSqlBaseWalker.java:706)
at org.hibernate.hql.internal.antlr.HqlSqlBaseWalker.query(HqlSqlBaseWalker.java:562)
at org.hibernate.hql.internal.antlr.HqlSqlBaseWalker.selectStatement(HqlSqlBaseWalker.java:299)
at org.hibernate.hql.internal.antlr.HqlSqlBaseWalker.statement(HqlSqlBaseWalker.java:247)
at org.hibernate.hql.internal.ast.QueryTranslatorImpl.analyze(QueryTranslatorImpl.java:278)
at org.hibernate.hql.internal.ast.QueryTranslatorImpl.doCompile(QueryTranslatorImpl.java:206)
... 72 more 

색인에서 양식.xhtml

<h:panelGrid id="panel1" columns="2" border="1"
                 cellpadding="5" cellspacing="1">
        <f:facet name="header">
            <h:outputText value="Add Customer Information"/>
        </f:facet>
        <h:outputLabel value="First Name:"/>
        <h:inputText value="#{customer.firstName}" id="fn"/>
        <h:outputLabel value="Last Name:"/>
        <h:inputText value="#{customer.lastName}" id="ln"/>
        <h:outputLabel value="Email:"/>
        <h:inputText value="#{customer.email}" id="eml"/>
        <h:outputLabel value="Date of Birth:"/>
        <h:inputText value="#{customer.sd}" id="s"/>
        <f:facet name="footer">
            <h:outputLabel value="#{customer.msg}" id="msg" styleClass="msg"/>
            <h:commandButton value="Save" action="#{customer.saveCustomer}">
            </h:commandButton>
        </f:facet>
    </h:panelGrid> 

Customer.java

    package com.javaknowledge.entity;

    import com.javaknowledge.dao.CustomerDao;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    import javax.faces.bean.ManagedBean;
    import javax.faces.bean.SessionScoped;
    import javax.persistence.*;    

    @ManagedBean
    @SessionScoped

    public class Customer implements java.io.Serializable {

    private Integer custId;
    private String firstName;
    private String lastName;
    private String email;
    private Date dob;
    private String sd, msg, selectedname;
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");


    public Customer() {
    }

    public Customer(String firstName, String lastName, String email, Date dob) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
        this.dob = dob;
    }

    public String getSd() {
        return sd;
    }

    public void setSd(String sd) {
        this.sd = sd;
    }

    public Integer getCustId() {
        return this.custId;
    }

    public void setCustId(Integer custId) {
        this.custId = custId;
    }

    public String getFirstName() {
        return this.firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return this.lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    @Column(name = "EMAIL")
    public String getEmail() {
        return this.email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Column(name = "DOB")
    public Date getDob() {
        return this.dob;
    }

    public void setDob(Date dob) {
        this.dob = dob;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getSelectedname() {
        return selectedname;
    }

    public void setSelectedname(String selectedname) {
        this.selectedname = selectedname;
    }

    public void saveCustomer() {
        try {
            Date d = sdf.parse(sd);
            System.out.println(d);
            this.dob = d;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        CustomerDao dao = new CustomerDao();
        dao.addCustomer(this);
        this.msg = "Member Info Saved Successfull!";
        clearAll();
    }
    public void updateCustomer() {
        try {
            Date d = sdf.parse(sd);
            System.out.println(d);
            this.dob = d;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        CustomerDao dao = new CustomerDao();
        dao.updateCustomer(this);
        this.msg = "Member Info Update Successfull!";
        clearAll();
    }
    public void deleteCustomer() {
        CustomerDao dao = new CustomerDao();
        dao.deleteCustomer(custId);
        this.msg = "Member Info Delete Successfull!";
        clearAll();
    }

    public List<Customer> getAllCustomers() {
        List<Customer> users = new ArrayList<Customer>();
        CustomerDao dao = new CustomerDao();
        users = dao.getAllCustomers();
        return users;
    }

    public void fullInfo() {
        CustomerDao dao = new CustomerDao();
        List<Customer> lc = dao.getCustomerById(selectedname);
        System.out.println(lc.get(0).firstName);
        this.custId = lc.get(0).custId;
        this.firstName = lc.get(0).firstName;
        this.lastName = lc.get(0).lastName;
        this.email = lc.get(0).email;
        this.dob = lc.get(0).dob;
        this.sd = sdf.format(dob);
    }

    private void clearAll() {
        this.firstName = "";
        this.lastName = "";
        this.sd = "";
        this.email = "";
        this.custId=0;
    }

   }

휴지 상태.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
  <session-factory>
    <property name="hibernate.dialect">org.hibernate.dialect.DerbyDialect</property>
    <property name="hibernate.connection.driver_class">org.apache.derby.jdbc.ClientDriver</property>
    <property name="hibernate.connection.url">jdbc:derby://localhost:1527/derbyDB</property>
    <property name="hibernate.connection.username">user1</property>
    <property name="hibernate.connection.password">user1</property>
    <property name="hibernate.hbm2ddl.auto">create</property>

    <property name="c3p0.min_size">1</property>
    <property name="c3p0.max_size">5</property>
    <property name="c3p0.timeout">300</property>
    <property name="c3p0.max_statements">50</property>
    <property name="c3p0.idle_test_period">300</property>

    <mapping class="com.javaknowledge.entity.Customer" resource="com/javaknowledge/entity/Customer.hbm.xml"/>
  </session-factory>
</hibernate-configuration>

Customer.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
  <class name="com.javaknowledge.entity.Customer" table="CUSTOMERV" schema="APP">
        <id name="custId" type="java.lang.Integer">
            <column name="cust_id" />
            <generator class="increment" />
        </id>
        <property name="firstName" type="string">
            <column name="first_name" length="45" not-null="true" />
        </property>
        <property name="lastName" type="string">
            <column name="last_name" length="45" not-null="true" />
        </property>
        <property name="email" type="string">
            <column name="email" length="45" not-null="true" />
        </property>
        <property name="dob" type="date">
            <column name="dob" length="10" not-null="true" />
        </property>
   </class>
</hibernate-mapping>

드디어 실수를 발견했어!이게 누군가에게 도움이 됐으면 좋겠다.데이터베이스에 요청을 할 때(내 경우 Apache Derby), 베이스 이름은 첫 번째 알파벳 대소문자를 입력해야 합니다.

잘못된 쿼리입니다.

session.createQuery("select first_name from CUSTOMERV").

유효한 쿼리입니다.

session.createQuery("select first_name from Customerv"). 

클래스 엔티티는 데이터베이스와 이름이 같아야 하는데 잘 모르겠어요.

HQL 쿼리에서 테이블 이름을 쓰지 말고 쿼리에 엔티티 클래스 이름을 씁니다.

String s = "from Entity_class name";
query qry = session.createUqery(s);

덧셈을 요.nativeQuery = true

@Query( value = "some sql query ...", nativeQuery = true)

스프링 데이터 JPA를 사용한 스프링 부트용

JPA 주석을 사용하여 엔티티를 만들고 테이블 이름이 @Entity 대신 @Table 주석과 함께 매핑되었는지 확인합니다.

매핑이 잘못됨:

@Entity(name="DB_TABLE_NAME")
public class DbTableName implements Serializable {
   ....
   ....
}

올바르게 매핑된 엔티티:

@Entity
@Table(name="DB_TABLE_NAME")
public class DbTableName implements Serializable {
   ....
   ....
}

hibernate.cfg.xml 파일에는 다음과 같은 테이블의 매핑이 포함되어 있어야 합니다.파일에 누락되지 않았는지 확인합니다.

......
<hibernate-configuration>
......
......
  <session-factory>
......
<mapping class="com.test.bean.dbBean.testTableHibernate"/>
......
 </session-factory>

</hibernate-configuration>
.....

다른 어떤 해결책도 제게는 효과가 없었습니다.

베스트 프랙티스가 아니라고 생각되더라도 이렇게 코드에 추가해야 했다.

configuration.addAnnotatedClass(com.myOrg.entities.Person.class);

여기서

public static SessionFactory getSessionFactory() {
    Configuration configuration = new Configuration().configure();

    configuration.addAnnotatedClass(com.myOrg.entities.Person.class);

    StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder()
            .applySettings(configuration.getProperties());
    SessionFactory sessionFactory = configuration.buildSessionFactory(builder.build());
    return sessionFactory;
}

이게 더 명확해질 수도 있고, 물론 이치에 맞겠죠.

@Entity
@Table(name = "users")

/**
 * 
 * @author Ram Srinvasan
 * Use class name in NamedQuery
 * Use table name in NamedNativeQuery
 */
@NamedQueries({ @NamedQuery(name = "findUserByName", query = "from User u where u.name= :name") })

@NamedNativeQueries({ @NamedNativeQuery(name = "findUserByNameNativeSQL", query = "select * from users u where u.name= :name", resultClass = User.class) })
public class User implements Principal {
...
}

클래스 이름을 사용했는데도 이 예외를 받을 기회가 한 번 더 있습니다. 즉, 같은 이름의 클래스가 서로 다른 패키지에 있는 경우 이 문제가 발생합니다.

휴지 상태에서는 애매모호해지고 이 예외가 발생할 수 있기 때문에 해결 방법은 완전한 수식 이름(com.test 등)을 사용하는 것입니다.커스텀 서비스)

말씀드린 대로 시나리오에 도움이 되는 답변을 추가했습니다.같은 시나리오가 한동안 막혔어요.

저도 Hibernate를 시작했을 때 비슷한 문제에 직면한 적이 있습니다.내가 말할 수 있는 것은 모두 창조에 있다.쿼리 엔티티가 매핑되는 테이블 이름이 아닌 엔티티 클래스의 이름을 전달해야 합니다.

즉, 테이블이 JPA에 매핑되어 있지 않습니다.테이블 이름이 잘못되었거나(대소문자가 구분될 수 있음) XML 파일에 엔트리를 넣어야 합니다.

해피 코딩 :)

하이버네이트용으로 매핑클래스를 사용하고 있는 다른 유저는, 가 모델 패키지에 올바르게 대응하고 있는 것을 확인해 주세요.sessionFactory콩:

<property name="packagesToScan" value="com.mblog.model"></property>

내 경우: 스프링 부트 2, 다중 데이터 소스(기본값과 커스텀)입니다. entityManager.createQuery ' map': 'map is not map

디버깅 중에 entityManager의 unitName이 잘못된 것을 알게 되었습니다(커스텀이어야 하지만 사실은 기본값입니다).

@PersistenceContext(unitName = "customer1") // !important, 
private EntityManager em;

customer1는 두 번째 입니다.두 데이터 소스 설정 클래스 두 번째 데이터 소스 설정 클래스입니다.

@Bean(name = "customer1EntityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder,
        @Qualifier("customer1DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.xxx.customer1Datasource.model")
            .persistenceUnit("customer1")
            // PersistenceUnit injects an EntityManagerFactory, and PersistenceContext
            // injects an EntityManager.
            // It's generally better to use PersistenceContext unless you really need to
            // manage the EntityManager lifecycle manually.
            // 【4】
            .properties(jpaProperties.getHibernateProperties(new HibernateSettings())).build();
}

그럼 entityManager가 맞네요

하지만 em.persist(엔티티)도 작동하지 않고 거래도 되지 않습니다.

또 다른 중요한 점은 다음과 같습니다.

@Transactional("customer1TransactionManager") // !important
public Trade findNewestByJdpModified() {
    //test persist,working right!
    Trade t = new Trade();
    em.persist(t);
    log.info("t.id" + t.getSysTradeId());

    //test transactional, working right!
    int a = 3/0;
}

customer1TransactionManager는 두 번째 입니다.두 데이터 소스 설정 클래스 두 번째 데이터 소스 설정 클래스입니다.

@Bean(name = "customer1TransactionManager")
public PlatformTransactionManager transactionManager(
        @Qualifier("customer1EntityManagerFactory") EntityManagerFactory entityManagerFactory) {
    return new JpaTransactionManager(entityManagerFactory);
}

두 번째 데이터 소스 설정 클래스 전체는 다음과 같습니다.

package com.lichendt.shops.sync;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "customer1EntityManagerFactory", transactionManagerRef = "customer1TransactionManager",
        // 【1】这里写的是DAO层的路径 ，如果你的DAO放在 com.xx.DAO下面，则这里写成 com.xx.DAO
        basePackages = { "com.lichendt.customer1Datasource.dao" })
public class Custom1DBConfig {

    @Autowired
    private JpaProperties jpaProperties;

    @Bean(name = "customer1DatasourceProperties")
    @Qualifier("customer1DatasourceProperties")
    @ConfigurationProperties(prefix = "customer1.datasource")
    public DataSourceProperties customer1DataSourceProperties() {
        return new DataSourceProperties();
    }

    @Bean(name = "customer1DataSource")
    @Qualifier("customer1DatasourceProperties")
    @ConfigurationProperties(prefix = "customer1.datasource") //
    // 【2】datasource配置的前缀，对应上面 【mysql的yaml配置】
    public DataSource dataSource() {
        // return DataSourceBuilder.create().build();
        return customer1DataSourceProperties().initializeDataSourceBuilder().build();
    }

    @Bean(name = "customer1EntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder,
            @Qualifier("customer1DataSource") DataSource dataSource) {
        return builder.dataSource(dataSource).packages("com.lichendt.customer1Datasource.model") // 【3】这里是实体类的包路径
                .persistenceUnit("customer1")
                // PersistenceUnit injects an EntityManagerFactory, and PersistenceContext
                // injects an EntityManager.
                // It's generally better to use PersistenceContext unless you really need to
                // manage the EntityManager lifecycle manually.
                // 【4】
                .properties(jpaProperties.getHibernateProperties(new HibernateSettings())).build();
    }

    @Bean(name = "customer1TransactionManager")
    public PlatformTransactionManager transactionManager(
            @Qualifier("customer1EntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

를 하고 있는 는, 를 가 있는 경우가 .bean언언을선 ::com.abc.spring가 「」로 되었습니다.com.bbc.spring

@Bean
    public SessionFactory sessionFactory() {

        LocalSessionFactoryBuilder builder = new LocalSessionFactoryBuilder(dataSource());
        //builder.scanPackages("com.abc.spring");    //Comment this line as this package no longer valid.
        builder.scanPackages("com.bbc.spring");
        builder.addProperties(getHibernationProperties());

        return builder.buildSessionFactory();
    }

em.create에 엔티티 클래스 이름을 사용해야 합니다.쿼리 메서드 또는 엔티티 클래스가 없는 네이티브 쿼리에 em.createNativeQuery 메서드를 사용해야 합니다.

엔티티 클래스 포함:

작성쿼리("CUSTOMERV에서 first_name 선택")

엔티티 클래스 또는 네이티브 쿼리 없음:

em.createNativeQuery("CUSTOMERV c에서 c.first_name 선택")

효과가 있었던 또 다른 솔루션:

이 예외를 실제로 발생시킨 데이터 액세스 개체는 다음과 같습니다.

public List<Foo> findAll() {
    return sessionFactory.getCurrentSession().createQuery("from foo").list();
}

위 스니펫에서 제가 한 실수는 create에서 foo라는 테이블명을 사용한 것입니다.질문입니다. 대신 실제 학급 이름인 Foo를 사용하게 되었습니다.

public List<Foo> findAll() {
    return sessionFactory.getCurrentSession().createQuery("from Foo").list();

다음 블로그 덕분에 https://www.arundhaj.com/blog/querysyntaxexception-not-mapped.html

Hibernate용으로 매핑클래스를 사용하고 있는 다른 사용자는 다음 파트에서 sessionFactory bean 선언의 모델 패키지에 주소가 올바르게 지정되어 있는지 확인하십시오.

public List<Book> list() {
    List<Book> list=SessionFactory.getCurrentSession().createQuery("from book").list();
    return list;
}

위 스니펫에서 제가 한 실수는 create에서 foo라는 테이블명을 사용한 것입니다.질문입니다. 대신 실제 학급 이름인 Foo를 사용하게 되었습니다.

public List<Book> list() {                                                                               
    List<Book> list=SessionFactory.getCurrentSession().createQuery("from Book").list();
    return list;
}

휴지 상태에서는,

session.createQuery("select first_name from Customerv"). 

Customerv테이블 이름이 아닌 엔티티 이름입니다.

Apache Derby DB에서 테이블 이름은 Apache Derby에서 예약된 키워드이지만 MySql에서 제대로 작동하므로 "user" 등으로 사용하지 마십시오.

쿼리의 FROM 절에서 데이터를 가져올 엔티티 클래스의 이름을 지정해야 합니다.

List<User> users=session.createQuery("from User").list();

여기서 User는 Java Entity 클래스의 이름입니다(Java에서는 대소문자를 사용합니다).

문제는 부분적으로 해결되었다.jdbc/resource(DB Derby) 작성 외에 Glassfish 관리 콘솔에서 DB 리소스용 JDBC Connection Pool을 생성하여 ping 시 확인해야 합니다.이것으로 모든 CRUD 조작은 정상적으로 동작합니다.확인하겠습니다.데이터베이스에 있는 Customer adding, update, delete도 올바르게 추가합니다.그러나 Glassfish 출력 로그에는 다음과 같은 예외가 있습니다.

SEVERE:   org.hibernate.hql.internal.ast.QuerySyntaxException: CUSTOMERV is not mapped [select concat(first_name, ' ', last_name) as name from CUSTOMERV]
    at org.hibernate.hql.internal.ast.QuerySyntaxException.generateQueryException(QuerySyntaxException.java:96)
    at org.hibernate.QueryException.wrapWithQueryString(QueryException.java:120)
    at org.hibernate.hql.internal.ast.QueryTranslatorImpl.doCompile(QueryTranslatorImpl.java:234)
    .......

Caused by: org.hibernate.hql.internal.ast.QuerySyntaxException: CUSTOMERV is not mapped
    at org.hibernate.hql.internal.ast.util.SessionFactoryHelper.requireClassPersister(SessionFactoryHelper.java:189)
    at org.hibernate.hql.internal.ast.tree.FromElementFactory.addFromElement(FromElementFactory.java:109)

매개 변수 nativeQuery = true를 추가합니다.

예: @Query(값="사용자 세트 user_name =:user_name,password =:password 여기서 user_id =:user_id",nativeQuery = true를 업데이트합니다.

언급URL : https://stackoverflow.com/questions/23018836/org-hibernate-hql-internal-ast-querysyntaxexception-table-is-not-mapped