从 JPA 原生查询中获取列名

Question

我的 Web 应用程序中有一个管理控制台，允许管理员对我们的数据库执行自定义 SQL SELECT 查询。

在下面，应用程序正在使用 Hibernate，但这些查询不是 HQL，它们是纯 SQL，所以我使用的是这样的 Native Query：

protected EntityManager em;

public List<Object[]> execute(String query) {
    Query q = em.createNativeQuery(query);
    List<Object[]> result = q.getResultList();
    return result;
}

这可以正常工作，但它只返回数据行，没有额外信息。我还想要获取列名，因此当我将结果打印回用户时，我还可以打印一个标题以显示各个列是什么。

有什么办法吗？

Answer 1

如果 JPA 提供程序不支持检索查询元数据，另一种解决方案可能是使用 SQL 解析器，如 JSQLParser、ZQL 或 General SQL Parser（商业），它从 @987654324 中提取字段@ 声明。

Answer 2

很久没有任何答案，而且根据我自己的进一步研究，似乎不可能，不幸的是。

Answer 3

我在使用 JPA 时也遇到了类似的问题。 JPA 中没有直接访问结果集元数据的方法。解决方案可以是从查询本身中提取列名，也可以使用 JDBC 来获取元数据。

Answer 4

将查询转换为休眠查询，然后使用休眠方法

          //normal use, javax.persistence.Query interface
    Query dbQuery = entityManager.createNativeQuery(sql);
    //cast to hibernate query
    org.hibernate.Query hibernateQuery =((org.hibernate.jpa.HibernateQuery)dbQuery)
            .getHibernateQuery();
    hibernateQuery.setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE);

    List<Map<String,Object>> res = hibernateQuery.list();

    List<TxTestModel> txTestModels = new ArrayList<>();
    res.forEach(e->{
        TxTestModel txTestModel = new ObjectMapper().convertValue(e, TxTestModel.class);
    //  txTestModels.add(new TxTestModel().setIdd((Integer) e.get("idd")).setMmm((String) e.get("mmm")).setDdd((Date) e.get("ddd")));
        txTestModels.add(txTestModel);
    });
    System.out.println(txTestModels.size());

Answer 5

这段代码对我有用

DTO 类：

 public class ItemResponse<T> {

 private T item;

 public ItemResponse() {
 }

 public ItemResponse(T item) {
   super();
   this.item = item;
 }

 public T getItem() {
    return item;
}

public void setItem(T item) {
    this.item = item;
}

}

服务类在下面

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import org.springframework.stereotype.Service;
import org.hibernate.transform.AliasToEntityMapResultTransformer;

@Service
public class ServiceClass{ 

@PersistenceContext
public EntityManager entityManager;

public ItemResponse exceuteQueryResponse(String queryString) {

        ItemResponse itemResponse=new ItemResponse();           
        Query jpaQuery =  entityManager.createNativeQuery(queryString);
        org.hibernate.Query hibernateQuery =((org.hibernate.jpa.HibernateQuery)jpaQuery).getHibernateQuery();
      hibernateQuery.setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE);
        List<Map<String,Object>> res = hibernateQuery.list();

        itemResponse.setItem(res);
        return itemResponse;

    }

    }

Answer 6

2020

使用 hibernate 5.2.11.Final 实际上很容易。 在我的示例中，您可以看到我如何获取每一行的列名。以及如何按列名获取值。

Query q = em.createNativeQuery("SELECT columnA, columnB FROM table");
List<Tuple> result = q.getResultList();

for (Tuple row: result){

    // Get Column Names
    List<TupleElement<Object>> elements = row.getElements();
    for (TupleElement<Object> element : elements ) {
        System.out.println(element.getAlias());
    }

    // Get Objects by Column Name
    Object columnA;
    Object columnB;
    try {
        columnA = row.get("columnA");
        columnB= row.get("columnB");
    } catch (IllegalArgumentException e) {
        System.out.println("A column was not found");
    }
}

Answer 7

Ryiad 的回答 DTO 增加了一些混乱，你应该远离它。 你应该解释说它只适用于休眠。

如果你像我一样需要保持列的顺序，你可以指定你自己的转换器。我从hibernate复制代码并将HashMap更改为LinkedHashMap：

import java.util.LinkedHashMap;
import java.util.Map;

import org.hibernate.transform.AliasedTupleSubsetResultTransformer;
import org.hibernate.transform.ResultTransformer;

/**
 * {@link ResultTransformer} implementation which builds a map for each "row", made up of each aliased value where the
 * alias is the map key. Inspired by {@link org.hibernate.transform.AliasToEntityMapResultTransformer}, but kepping the
 * ordering of elements.
 * <p/>
 * Since this transformer is stateless, all instances would be considered equal. So for optimization purposes we limit
 * it to a single, singleton {@link #INSTANCE instance}.
 */
public class AliasToEntityMapResultTransformer extends AliasedTupleSubsetResultTransformer {

    public static final AliasToEntityMapResultTransformer INSTANCE = new AliasToEntityMapResultTransformer();

    /**
     * Disallow instantiation of AliasToEntityMapResultTransformer.
     */
    private AliasToEntityMapResultTransformer() {
    }

    @Override
    public Object transformTuple(Object[] tuple, String[] aliases) {
        Map result = new LinkedHashMap<>(tuple.length);
        for (int i = 0; i < tuple.length; i++) {
            String alias = aliases[i];
            if (alias != null) {
                result.put(alias, tuple[i]);
            }
        }
        return result;
    }

    @Override
    public boolean isTransformedValueATupleElement(String[] aliases, int tupleLength) {
        return false;
    }

    /**
     * Serialization hook for ensuring singleton uniqueing.
     *
     * @return The singleton instance : {@link #INSTANCE}
     */
    private Object readResolve() {
        return INSTANCE;
    }
}

有了这个转换器，你可以在 Hibernate 中使用 Ryiad 的解决方案：

    Query jpaQuery =  entityManager.createNativeQuery(queryString);
    org.hibernate.Query hibernateQuery =((org.hibernate.jpa.HibernateQuery)jpaQuery).getHibernateQuery();
  hibernateQuery.setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE);
    List<Map<String,Object>> res = hibernateQuery.list();

Answer 8

要强制 em.createNativeQuery(..).getResultList() 返回 List<Tuple> 在创建本机查询时使用 Tuple.class 指定它：

Query q = em.createNativeQuery("SELECT columnA, columnB FROM table", Tuple.class );

List<Tuple> result = q.getResultList();

for (Tuple row: result){

    // Get Column Names
    List<TupleElement<Object>> elements = row.getElements();
    for (TupleElement<Object> element : elements ) {
        System.out.println(element.getAlias());
    }

    // Get Objects by Column Name
    Object columnA;
    Object columnB;
    try {
        columnA = row.get("columnA");
        columnB= row.get("columnB");
    } catch (IllegalArgumentException e) {
        System.out.println("A column was not found");
    }

}

Answer 9

Query query = entityManager.createNamedQuery(namedQuery);
NativeQueryImpl nativeQuery = (NativeQueryImpl) query;
nativeQuery.setResultTransformer(AliasToEntityMapResultTransformer.INSTANCE);
List<Map<String,Object>> result = nativeQuery.getResultList();

现在你有了 Map 。你可以看到你的列名

Answer 10

这对我有用：

    final Query emQuery = em.createNativeQuery(query, Tuple.class);
    final List<Tuple> queryRows = emQuery.getResultList();

    final List<Map<String, Object>> formattedRows = new ArrayList<>();

    queryRows.forEach(row -> {
        final Map<String, Object> formattedRow = new HashMap<>();

        row.getElements().forEach(column -> {
            final String columnName = column.getAlias();
            final Object columnValue = row.get(column);

            formattedRow.put(columnName, columnValue);
        });
        
        formattedRows.add(formattedRow);
    });

    return formattedRows;