hibernate查询结果行转列

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量265 收藏
点赞数
分类专栏： Java 文章标签： java hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014459738/article/details/111052005
版权

业务说明

对应的业务需求
每个X对应的每项Y的Z值，将Y作为行纬度将X作列纬度展示Z的值
举例：已知每个学生对应的每道题的得分 二纬表，转换为每道题每个学生的得分二纬表。

hibernate 查询sql对应的代码

String _sql = "select id, pm, yhdm, name, df from Student_Score";
//表说明：
//Student_Score 每个学生每道题目的得分明细表
//id 为Student_Score 主键列
//pm 题目表的外键
//yhdm 学生表的外键
//name 学生表中的名称（此处可以用自查询获取对应的名称）
//df 学生对应题目的得分
private List<Map<String, Object>> loadTableData(String _sql){
    HibernateSession sess = HibernateSessionFactory.getSession(this.getClass());
    return sess.createSQLQuery(_sql).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).list();
}

查询出的结果如下：

｜id: 100 ｜pm: 1 ｜ name:张三 ｜yhdm:1 ｜ df:11 ｜
｜id: 101 ｜pm: 2 ｜ name:张三 ｜yhdm:1 ｜ df:12 ｜
｜id: 102 ｜pm: 3 ｜ name:张三 ｜yhdm:1 ｜ df:13 ｜
｜id: 103 ｜pm: 1 ｜ name:李四 ｜yhdm:2 ｜ df:21 ｜
｜id: 104 ｜pm: 2 ｜ name:李四 ｜yhdm:2 ｜ df:22 ｜
｜id: 105 ｜pm: 3 ｜ name:李四 ｜yhdm:2 ｜ df:23 ｜
｜id: 106 ｜pm: 1 ｜ name:王武 ｜yhdm:3 ｜ df:31 ｜
｜id: 107 ｜pm: 2 ｜ name:王武 ｜yhdm:3 ｜ df:32 ｜
｜id: 108 ｜pm: 3 ｜ name:王武 ｜yhdm:4 ｜ df:33 ｜

执行转换后如下：

返回结果key设计说明
yhdm_2-df : 放入了原始表中的 yhdm 的 key_val 组合
yhdm_3-id：放入了原始表中的 yhdm 的 key_val 组合
已上两个key 只要在一行，就能通过 替换"-"后面的 df 与 id ,从而找到 此df对应的val在原始表中的唯一位置。
pm : 转换后行的唯一值

| yhdm_2-df : 李四 || yhdm_1-df : 张三 || yhdm_3-df : 王武 |
--------------
| yhdm_2-df : 21 || yhdm_1-df : 11 || yhdm_3-df : 31 || yhdm_3-id : 106 || yhdm_2-id : 103 || pm : 1 || yhdm_1-id : 100 |
--------------
| yhdm_2-df : 22 || yhdm_1-df : 11 || yhdm_3-df : 32 || yhdm_3-id : 107 || yhdm_2-id : 104 || pm : 2 || yhdm_1-id : 101 |
--------------
| yhdm_2-df : 23 || yhdm_1-df : 11 || yhdm_3-df : 33 || yhdm_3-id : 108 || yhdm_2-id : 105 || pm : 3 || yhdm_1-id : 102 |
--------------

使用

创建Java文件 Utils.java
在项目跟目录，没有包 复制代码可直接运行 main方法

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Utils {

    public static List<Map<String, Object>> row_to_column_keyUp(List<Map<String, Object>> sourceData, String sourceIdKey,String sourceOneKey, String sourceTwoKeyInt, String sourceTwoKeyStr, String sourceLastKey){
        return row_to_column(sourceData, sourceIdKey.toUpperCase(), sourceOneKey.toUpperCase(), sourceTwoKeyInt.toUpperCase(), sourceTwoKeyStr.toUpperCase(), sourceLastKey.toUpperCase());
    }
    /**
     * 行列转换
     * 转换前
     * ｜id: 100｜pm: 1 ｜ name:张三 ｜yhdm:1 ｜ df:11 ｜
     * ｜id: 101｜pm: 2 ｜ name:张三 ｜yhdm:1 ｜ df:12 ｜
     * ｜id: 102｜pm: 3 ｜ name:张三 ｜yhdm:1 ｜ df:13 ｜
     * ｜id: 103｜pm: 1 ｜ name:李四 ｜yhdm:2 ｜ df:21 ｜
     * ｜id: 104｜pm: 2 ｜ name:李四 ｜yhdm:2 ｜ df:22 ｜
     * ｜id: 105｜pm: 3 ｜ name:李四 ｜yhdm:2 ｜ df:23 ｜
     * ｜id: 106｜pm: 1 ｜ name:王武 ｜yhdm:3 ｜ df:31 ｜
     * ｜id: 107｜pm: 2 ｜ name:王武 ｜yhdm:3 ｜ df:32 ｜
     * ｜id: 108｜pm: 3 ｜ name:王武 ｜yhdm:4 ｜ df:33 ｜
     * 转换后
     * | yhdm_1-df:张三 ｜ yhdm_2-df:李四 ｜ yhdm_3-df:王武 ｜
     * ｜ pm:1 ｜ yhdm_1-id:100 ｜yhdm_1-df:11 ｜ yhdm_2-id:103 | yhdm_2-df:21 ｜ yhdm_3-id:106 | yhdm_3-df:31 ｜
     * ｜ pm:2 ｜ yhdm_1-id:102 ｜yhdm_1-df:12 ｜ yhdm_2-id:104 | yhdm_2-df:22 ｜ yhdm_3-id:107 | yhdm_3-df:32 ｜
     * ｜ pm:3 ｜ yhdm_1-id:103 ｜yhdm_1-df:13 ｜ yhdm_2-id:105 | yhdm_2-df:23 ｜ yhdm_3-id:108 | yhdm_3-df:33 ｜
     * @return
     */
    public static List<Map<String, Object>> row_to_column(List<Map<String, Object>> sourceData, String sourceIdKey,String sourceOneKey, String sourceTwoKeyInt, String sourceTwoKeyStr, String sourceLastKey){
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        Map<String, Object> one_row_map_result = new HashMap<String , Object>();
        // one_row_map_result.put(sourceOneKey + sourceTwoKeyInt, "-");
        for(Map<String, Object> source_map : sourceData){
            String oneKeyValue = sourceOneKey + "_" + source_map.get(sourceOneKey);
            String twoKeyIndexValue = sourceTwoKeyInt + "_" + source_map.get(sourceTwoKeyInt);
            String idKeyValue = sourceIdKey + "_" + source_map.get(sourceIdKey);
            //判断返回结果第一行是否已存在对应的转换key yhdm_1-df:张三
            String one_row_key_result = twoKeyIndexValue + "-" + sourceLastKey;
            if(!one_row_map_result.containsKey(one_row_key_result)){
                //返回结果 第一行添加
                one_row_map_result.put(one_row_key_result, source_map.get(sourceTwoKeyStr));
            }
            Map<String, Object> row_map_result = new HashMap<String , Object>();
            //返回结果中 是否已存在对应的key值
            int mapIndex = getMayIndex(result, sourceOneKey, source_map.get(sourceOneKey));
            if( mapIndex != -1){
                //存在，获取到对应的index
                row_map_result = result.get(mapIndex);
            }else{
                //不存在
                row_map_result.put(sourceOneKey, source_map.get(sourceOneKey));
            }
            //数据单元格的id yhdm_1-id:100
            String row_key_result = twoKeyIndexValue + "-" + sourceIdKey;
            if(!row_map_result.containsKey(row_key_result)){
                row_map_result.put(row_key_result, source_map.get(sourceIdKey));
            }
            //数据单元格的值 yhdm_1-df:11
            if(!row_map_result.containsKey(one_row_key_result)){
                row_map_result.put(one_row_key_result, source_map.get(sourceLastKey));
            }
            

            //返回结果不存在添加数据
            if( mapIndex == -1){
                result.add(row_map_result);
            }
            
        }
        //插入第一行数据
        result.add( 0, one_row_map_result);
        return result;
    }

    /**
     * list 中已存在对应key的值
     * @param datas
     * @param key
     * @param value
     * @return 集合所在位置索引 或 -1
     */
    public static int getMayIndex(List<Map<String, Object>> datas, String key, Object value){
        for(int i = 0; i < datas.size(); i++){
            Map<String, Object> _data = datas.get(i);
            //返回值中已经存在对应的key
            if(value == null){
                return -1;
            }
            if(value.equals(_data.get(key))){
                return i;
            }
        }
        return -1;
    }


    /**
     * ｜id: 100 ｜pm: 1 ｜ name:张三 ｜yhdm:1 ｜ df:11 ｜
     * ｜id: 101 ｜pm: 2 ｜ name:张三 ｜yhdm:1 ｜ df:12 ｜
     * ｜id: 102 ｜pm: 3 ｜ name:张三 ｜yhdm:1 ｜ df:13 ｜
     * ｜id: 103 ｜pm: 1 ｜ name:李四 ｜yhdm:2 ｜ df:21 ｜
     * ｜id: 104 ｜pm: 2 ｜ name:李四 ｜yhdm:2 ｜ df:22 ｜
     * ｜id: 105 ｜pm: 3 ｜ name:李四 ｜yhdm:2 ｜ df:23 ｜
     * ｜id: 106 ｜pm: 1 ｜ name:王武 ｜yhdm:3 ｜ df:31 ｜
     * ｜id: 107 ｜pm: 2 ｜ name:王武 ｜yhdm:3 ｜ df:32 ｜
     * ｜id: 108 ｜pm: 3 ｜ name:王武 ｜yhdm:4 ｜ df:33 ｜
     * @param args
     */
    public static void main(String[] args) {
        List<Map<String, Object>> datas = new ArrayList<>();
        Map<String, Object> t1 = new HashMap<String, Object>();
        t1.put("id", 100);
        t1.put("pm", 1);
        t1.put("name", "张三");
        t1.put("yhdm", "1");
        t1.put("df", "11");
        datas.add(t1);
        Map<String, Object> t2 = new HashMap<String, Object>();
        t2.put("id", 101);
        t2.put("pm", 2);
        t2.put("name", "张三");
        t2.put("yhdm", "1");
        t2.put("df", "11");
        datas.add(t2);
        Map<String, Object> t3 = new HashMap<String, Object>();
        t3.put("id", 102);
        t3.put("pm", 3);
        t3.put("name", "张三");
        t3.put("yhdm", "1");
        t3.put("df", "11");
        datas.add(t3);
        Map<String, Object> t4 = new HashMap<String, Object>();
        t4.put("id", 103);
        t4.put("pm", 1);
        t4.put("name", "李四");
        t4.put("yhdm", "2");
        t4.put("df", "21");
        datas.add(t4);
        Map<String, Object> t5 = new HashMap<String, Object>();
        t5.put("id", 104);
        t5.put("pm", 2);
        t5.put("name", "李四");
        t5.put("yhdm", "2");
        t5.put("df", "22");
        datas.add(t5);
        Map<String, Object> t6 = new HashMap<String, Object>();
        t6.put("id", 105);
        t6.put("pm", 3);
        t6.put("name", "李四");
        t6.put("yhdm", "2");
        t6.put("df", "23");
        datas.add(t6);
        Map<String, Object> t7 = new HashMap<String, Object>();
        t7.put("id", 106);
        t7.put("pm", 1);
        t7.put("name", "王武");
        t7.put("yhdm", "3");
        t7.put("df", "31");
        datas.add(t7);
        Map<String, Object> t8 = new HashMap<String, Object>();
        t8.put("id", 107);
        t8.put("pm", 2);
        t8.put("name", "王武");
        t8.put("yhdm", "3");
        t8.put("df", "32");
        datas.add(t8);
        Map<String, Object> t9 = new HashMap<String, Object>();
        t9.put("id", 108);
        t9.put("pm", 3);
        t9.put("name", "王武");
        t9.put("yhdm", "3");
        t9.put("df", "33");
        datas.add(t9);

        List<Map<String, Object>> result =  row_to_column(datas, "id","pm", "yhdm", "name", "df");
        for(Map<String, Object> map : result){

            for(String key:map.keySet()){//keySet获取map集合key的集合  然后在遍历key即可
                String value = map.get(key).toString();//
                System.out.print("| "+ key +" : "+ value +" |");
            }
            System.out.println("");
            System.out.println("--------------");
        }
    }
}

main执行结果

| yhdm_2-df : 李四 || yhdm_1-df : 张三 || yhdm_3-df : 王武 |
--------------
| yhdm_2-df : 21 || yhdm_1-df : 11 || yhdm_3-df : 31 || yhdm_3-id : 106 || yhdm_2-id : 103 || pm : 1 || yhdm_1-id : 100 |
--------------
| yhdm_2-df : 22 || yhdm_1-df : 11 || yhdm_3-df : 32 || yhdm_3-id : 107 || yhdm_2-id : 104 || pm : 2 || yhdm_1-id : 101 |
--------------
| yhdm_2-df : 23 || yhdm_1-df : 11 || yhdm_3-df : 33 || yhdm_3-id : 108 || yhdm_2-id : 105 || pm : 3 || yhdm_1-id : 102 |
--------------
coke_lang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HQL之常用的行列转换应用总结
石榴姐yyds
05-30 1400
行列转换是数据开发者的基本技能，也是面试重点，在数据开发中处处可见，本文对常见的几种情况进行了总结，包括了多行转多列，多行转单列，多列转多行，单列转多行的几种情况，并给出了解决思路和方法，读者可根据本文给出的思路灵活应对业务中遇到的问题。
对Hibernate 查询结果排序
王康的技术博客
03-27 2083
1、普通的查询排序，直接写HQL语句即可，即加上order by column2、一对多里面对set的排序，建议采用以下办法：首先，将POJO中的set成员的类型改为TreeSet类型，因为TreeSet是实现了SortedSet的可排序集合类。private Set labproductflowinfos = new TreeSet(new FlowInfoComparator());//为TreeSet提供一个自定义的比较器然后修改配置文件，为添加sort属性，属性取值可以为一个自定义的比较器。如下：p
hibernate执行sql 行转列
mengzhongxue的专栏
08-25 908
String hql = "select a.*,a.measure,b.productId,b.product from (select code,name,measure,"; int count = 0; if(mm==2){ count=30; }else if(mm==1||mm==3||mm==5||mm==7||mm==8||mm==10||mm==12){ count=3
Hibernate中的关系映射
zxkzhang的博客
10-12 107
Hibernate中的关系映射 都需要 hibernate.cfg.xml 中配置 mapper * hibernate.cfg.xml <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hiberna...
JAVAWEB开发之Hibernate详解（二）——Hibernate的持久化类状态与转换、以及一级缓存详解、关联关系的映射（一对多、多对多、级联）...
iteye_18817的博客
04-03 850
持久化对象的状态 Hibernate持久化对象存在三种状态： 瞬时态 transient:(临时态) 不存在持久化标识OID，尚未与Hibernate Session关联对象，被认为是瞬时状态，失去引用将被JVM回收。特点：无持久化标识OID，未与Session关联。 持久态 persistent:存在持久化标识OID，与当前Session有关联，并且相关联的Session没有关闭，并且事务未提交...
hibernate 列数据转换
weixin_43632687的博客
11-04 490
在需要转换的model字段上添加注释 @ColumnTransformer(read="kg*1000",write="?/1000") 表结构： model： @Entity @Table(name = "testguid") public class GUID implements Serializable { @Id @Column(name = "guid") @Generat...
hibernate查询方式
sushauai的博客
03-17 696
总的来说，hibernate查询方式可以分为以下几种： HQL，QBC，SQL，QBE，EJBQL 我先来简单解释以下这几种查询方式，具体后面会讲。 HQL：Hibernate Query Language 是面向对象的查询语言, 它和 SQL 查询语言有些相似. 在 Hibernate 提供的各种检索方式中, HQL 是使用最广的一种检索方式。QBC：Query By Criteria比HQ
java行转列的例子
12-10
"java行转列"这个主题是数据处理中的一个常见需求，尤其是在数据分析、报表生成或数据显示时。当我们从数据库中获取数据，有时会遇到单个字段的数据需要在用户界面上以列的形式展示，这时就需要进行数据的行列转换。...
hibernate将本地SQL查询结果封装成对象（最终）.zip
08-26
- 如果查询结果中包含多张表的数据，可以使用`setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP)`将结果转换为Map，键为列名，值为对应列的值。 通过理解并掌握以上内容，开发者可以有效地利用Hibernate将...
在Java的Hibernate框架中使用SQL语句的简单介绍
09-02
这里，`{usr.*}`表示将所有列映射到`usr`别名，`addEntity`方法将`usr`别名与`TUser`类关联，使得查询结果能自动转换为`TUser`对象的列表。 有时，你可能只想选择特定的列，你可以使用`AS`关键字来指定别名，并在...
Hibernate练习题
06-26
- 有四种主要检索方式：HQL（Hibernate查询语言）、Criteria API、Query API（基于JPA的查询）、Native SQL。 12. 对象何时变为游离状态： - 在Hibernate中，当Session关闭时，所有与之关联的持久化对象变为游离...
jpa 别名转实体
03-07
在JPA中，我们经常需要处理SQL查询结果，这些结果可能包含别名，例如在HQL（Hibernate Query Language）或JPQL（Java Persistence Query Language）查询中定义的别名。别名的作用是为了使查询语句更加简洁易读，并且...
hibernate 报表查询,实现行变列
leopard0825的专栏
12-01 107
http://5211422.iteye.com/blog/322542 这篇文章中介绍了sql语句实现的行变列. 但是如果使用Hibernate怎么来做呢,今天摸索了一天,终于小有所成,通过Hibernat的投影(Projections)实现了行变列的变态排版,同时还要考虑到分页的支持,做起来还是有点麻烦的.下面是具体代码:     Daoimpl.java代码 ...
HQL之行转列与列转行
weixin_40129969的博客
05-12 1796
HQL之行转列与列转行行转列与列转行的概述行转列什么是行转列行转列函数CONCATCONCAT_WSCOLLECT_SET（a）COLLECT_LIST（a）例子数据需求实现列转行什么是列转行列转行函数lateral viewexplodesplit例子需求创建数据建表并导入数据按照需求查询数据查询结果 行转列与列转行的概述 行转列函数和列转行函数本质上是聚合和拆分的两种类型的函数，我们将这些整理起来放在一起，一类成为行转列，一类称为列转行。 行转列 什么是行转列 把一行中不同列的数据放在同一列当中 (co
HQL的列转行和行转列
孙大迪迪的博客
11-29 3405
列转行 测试数据 hive&amp;gt; select * from col_lie limit 10; OK col_lie.user_id col_lie.order_id 104399 1715131 104399 2105395 104399 1758844 104399 981085 104399 2444143 104399 1458638 1043...
Hive_HQL_行转列与列转行
热门推荐
迎难而上
06-07 1万+
参考文章： 1.HIVE行转列和列转行 https://www.cnblogs.com/blogyuhan/p/9274784.html 2.HIVE行转列和列转行 https://blog.csdn.net/jiantianming2/article/details/79189672 列转行 方式一 ： 通过 GROUP BY + CASE WHEN + 聚合函数 需求如下 1.有用户学习情况的 uid, 科目，分数 多行数据。已知每个人所学分为英语，数学，...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1100
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
hibernate查询结果map集合
05-16
可以使用 Hibernate 提供的 `ResultTransformer` 接口来将查询结果转换成 Map 集合。 以下是一个示例代码： ```java Query query = session.createQuery("SELECT u.id, u.name FROM User u"); query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); List<Map<String, Object>> result = query.list(); ``` 在这个示例中，我们使用 Hibernate 的 `createQuery` 方法来创建一个查询，查询语句是 `SELECT u.id, u.name FROM User u`，它会返回 `id` 和 `name` 两列数据。 接着，我们调用 `setResultTransformer` 方法来设置结果转换器，将结果转换成 `Map` 集合。`Transformers.ALIAS_TO_ENTITY_MAP` 是一个预定义的结果转换器，它将结果转换成一个 `Map` 集合，键是列别名，值是列值。 最后，我们调用 `list` 方法来执行查询，并将查询结果保存到一个 `List` 集合中，每个元素都是一个 `Map` 集合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值