JPQL构造函数表达式 - org.hibernate.hql.ast.QuerySyntaxException：表未映射 [英] JPQL Constructor Expression - org.hibernate.hql.ast.QuerySyntaxException:Table is not mapped

问题描述

我原来的问题是 https://stackoverflow.com/questions/12172614/hql -boin-without-foreign-key-reference
，但找不到任何解决方案，因此使用JPA进行原生查询。 entityManager的createNativeQuery返回Query对象，然后返回 List< Object []> 。我不想在迭代列表时处理索引，因为它本质上是错误的。因此，我查看了一些其他解决方案，并发现JPQL的构造函数表达式是解决方案之一。

表结构是

$ $ p $ code> Schema1 -TableA

- NameColumn
- PhoneColumn

对应的Java类是

  public class PersonSearch implements Serializable {
 
 public PersonSearch（String NameColumn，String PhoneColumn）{
 this.name = NameColumn; 
 this.phone = PhoneColumn; 
} 
 
私人字符串名称; 
 
私人字符串电话; 
 
 public String getName（）{
 return name; 
} 
 
 public void setName（String name）{
 this.name = name; 
} 
 
 public String getPhone（）{
 return phone; 
} 
 
 public void setPhone（String phone）{
 this.phone = phone; 
 
 
 $ / code $ / pre 
 
查询是
 
 
 选择新的com.xyz.PersonSearch（ms.NameColumn，ms.PhoneColumn）从Schema1.TableA ms其中ms.PhoneColumn ='9134409930'
  
使用entityManager API运行此查询
  entityManager.createQuery（queryString，PersonSearch.class）; 
  
得到低于错误值。 
 
 
 原因：org.hibernate.hql.ast.QuerySyntaxException：Schema1.TableA未映射[Select new com.xyz.PersonSearch（ms.NameColumn，ms.PhoneColumn）From Schema1.TableA ms Where ms .PHONE ='9134409930'] 
  
我的代码有什么问题？任何想法？根据书Pro EJB 3 Java Persistence API 
 $ b 解释方案 $ b 
 构造函数表达式 
 $ b 
 
 
更强大的 SELECT 涉及多个表达式的code>子句是构造函数
表达式，它指定查询的结果将使用用户指定的
对象类型进行存储。考虑以下查询：
 $ b 
  SELECT NEW example.EmployeeDetails（e.name，e.salary， e.department.name）
 FROM雇员e 
  
此查询的结果类型是键入 example.EmployeeDetails 。当查询处理器
迭代查询结果时，它使用
构造函数实例化 EmployeeDetails 的新实例，该构造函数与查询。在这种情况下，表达式
类型是String，Double和String，因此查询引擎将搜索带有
类类型参数的构造函数。因此，生成的查询集合中的每一行都是包含员工姓名，工资和部门名称的
  EmployeeDetails 的实例。
 
 
 
必须使用对象的完全限定名称引用结果对象类型。然而，
类不必以任何方式映射到数据库。任何具有与 SELECT 子句中列出的表达式兼容的构造函数
的类都可以用在构造函数
表达式中。
 
 
 
构造函数表达式是用于构建粗粒度数据传输
对象或用于其他应用程序层的视图对象的强大工具。而不是手动构建
这些对象，可以使用单个查询将网页上呈现
的视图对象收集在一起。
 
 
示例代码如下
 列表结果= em.createQuery（SELECT NEW example.EmpMenu （e.name，e.department.name）+ 
FROM Project p JOIN p.employees e+ 
WHERE p.name =？1+ 
ORDER BY e .name）。setParameter（1，projectName）.getResultList（）; 
  
 EmpMenu类是一个简单的pojo，没有注释，但具有正确的构造函数来匹配构造函数表达式。结果是每个返回的行的EmpMenu对象列表。  
 
 
我相信你的SQL的一部分.... Schema1.TableA ms ..应该指向映射的实体。所以你应该有一个映射到TableA的实体，然后jpql应该更多地沿着...... MyTableAEntity ms ...的行，其中MyTableAEntity具有将其映射到DB表TableA的所有适当jpa注释。正如本书的片段所述，SELECT NEW ...的目标不必被映射，但FROM子句中引用的实体不需要。
 
My original problem was https://stackoverflow.com/questions/12172614/hql-join-without-foreign-key-reference
but couldn't find any solution for this, hence moved forward with native query using JPA. createNativeQuery of entityManager returns Query object which in turn returns List<Object[]>. I don't want to deal with indexes while iterating the list because it's error prone in nature.Therefore i looked at some other solution for it and found JPQL's Constructor expressions as one of the solution.

Table structure is
Schema1 -TableA

 - NameColumn
 - PhoneColumn
Corresponding Java class is
    public class PersonSearch implements Serializable {

    public PersonSearch (String NameColumn, String PhoneColumn) {
        this.name = NameColumn;
        this.phone = PhoneColumn;
    }

    private String name;

    private String phone;

    public String getName() {
    return name;
    }

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

    public String getPhone() {
    return phone;
    }

    public void setPhone(String phone) {
    this.phone = phone;
    }
    }
Query is
 Select NEW com.xyz.PersonSearch(ms.NameColumn, ms.PhoneColumn) From Schema1.TableA ms Where ms.PhoneColumn='9134409930'
while running this query using entityManager API
entityManager.createQuery(queryString, PersonSearch.class);
getting below error.
Caused by: org.hibernate.hql.ast.QuerySyntaxException: Schema1.TableA is not mapped   [Select NEW com.xyz.PersonSearch(ms.NameColumn, ms.PhoneColumn) From Schema1.TableA ms Where ms.PHONE='9134409930']
What's wrong with my code? Any idea ?
解决方案
according to the book "Pro EJB 3 Java Persistence API"

Constructor Expressions

  
A more powerful form of SELECT clause involving multiple expressions is the constructor
  expression, which specifies that the results of the query are to be stored using a user-specified
  object type. Consider the following query:
SELECT NEW example.EmployeeDetails(e.name, e.salary, e.department.name)
FROM Employee e
The result type of this query is the type example.EmployeeDetails. As the query processor
  iterates over the results of the query, it instantiates new instances of EmployeeDetails using the
  constructor that matches the expression types listed in the query. In this case the expression
  types are String, Double, and String, so the query engine will search for a constructor with those
  class types for arguments. Each row in the resulting query collection is therefore an instance of
  EmployeeDetails containing the employee name, salary, and department name.
  
  
The result object type must be referred to using the fully qualified name of the object. The
  class does not have to be mapped to the database in any way, however. Any class with a constructor
  compatible with the expressions listed in the SELECT clause can be used in a constructor
  expression.
  
  
Constructor expressions are powerful tools for constructing coarse-grained data transfer
  objects or view objects for use in other application tiers. Instead of manually constructing
  these objects, a single query can be used to gather together view objects ready for presentation
  on a web page.
The example code is as follows
List result = em.createQuery("SELECT NEW example.EmpMenu(e.name, e.department.name) " +
         "FROM Project p JOIN p.employees e " +
         "WHERE p.name = ?1 " +
        "ORDER BY e.name").setParameter(1, projectName).getResultList();
The  EmpMenu class is a simple pojo, no annotations but has the correct constructor to match the constructor expression. The result is a List of EmpMenu objects for each row returned. 

I believe the part of your SQL ".... From Schema1.TableA ms .." should refer to an entity that is mapped. So you should have an entity mapped to TableA, and then the jpql should be something more along the lines of ".... From MyTableAEntity ms ..." where MyTableAEntity has all the proper jpa annotations mapping it to DB table TableA. As the book snippet states, the target of "SELECT NEW ..." does not have to be mapped, but the entity referred to in the FROM clause does.

                        
这篇关于JPQL构造函数表达式 -  org.hibernate.hql.ast.QuerySyntaxException：表未映射的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！