HQL数据查询基础

最新推荐文章于 2022-02-10 18:00:17 发布
最新推荐文章于 2022-02-10 18:00:17 发布
阅读量461 收藏
点赞数 1
分类专栏： hibernate MySql 文章标签： hibernate java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013435893/article/details/79073884
版权

了解HQL

HQL定义

HQL:Hibernate Query Language, Hibernate查询语句

HQL 查询语句是面向对象的, Hibernate 负责解析 HQL 查询语句, 然后根据对象-关系映射文件中的映射信息, 把 HQL 查询语句翻译成相应的 SQL 语句。HQL 查询语句中的主体是域模型中的类及类的属性。

SQL 查询语句是与关系数据库绑定在一起的。SQL 查询语句中的主体是数据库表及表的字段。

初学HQL注意的问题

  1. HQL是面向对象的查询语言，对Java类的与属性大小写敏感
  2. HQL对关键字不区分大小写

HQL数据查询基础

基础简介

HQL 查询包括以下步骤:
1. 获取Hibernate Session对象。
2. 编写HQL语句
3. 以HQL语句作为参数，调用Session的createQuery方法创建查询对象。
4. 如果HQL语句包含参数，则调用Query的setXxx方法为参数赋值。
5. 调用Query对象的list()或uniqueResult()方法返回查询结果列表（持久化实体集）

Query接口简介

org.hibernate.Query接口
1. Query接口定义有执行查询的方法
2. Query接口支持方法链编程风格，使得程序代码更为简洁

Query实例的创建：
1. Session的createQuery()方法创建Query实例
2. createQuery方法包含一个HQL语句参数，createQuery(hql)
它的 setXxx() 方法返回自身实例, 而不是 void 类型，因此可以写类似于.setXxx().setXxx().setXxx()…样式的语句。

Query执行查询:
1. Query接口的list()方法执行HQL查询
2. list()方法返回结果数据类型为java.util.List，List集合中存放符合查询条件的持久化对象

数据库建立

这里以一个简单的网上购物为原型，整个数据库中各表之间的关系图如下：
各表之间的关系

Java项目创建

基本的项目搭建这里就不详细介绍了，可以参考之前的文章。
这里直接进行单元测试，测试一个简单的HQL语句

@Test
public void testSeller() {
    String hql = "from Seller";

    Query query = session.createQuery(hql);

    List<Seller> list = query.list();
    for (Seller seller : list) {
        System.out.println(seller);
    }
}

from子句

在HQL语句中，FROM语句是HQL语句的最简形式，是因为from指定了HQL语句查询主体->持久化类及其属性。
而SQL语句，SQL必须包含SELECT和FROM子句。

刚才上面那个测试其实就是一个简单的from子句，不过它所查询的是简单的映射对象，不存在关联关系的。这里我们以商品类Commodity为例做一次查询，Commodity中包含了Seller属性。 也就相当于说多个商品对应一个商家

@Test
public void findTest() {
    String hql = "from Commodity";

    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName());
    }
}

这里只做简单的输出，通过控制台可以看到查询所涉及到的sql语句

select
    commodity0_.ID as ID1_0_,
    commodity0_.NAME as NAME2_0_,
    commodity0_.PRICE as PRICE3_0_,
    commodity0_.UNIT as UNIT4_0_,
    commodity0_.CATEGORY as CATEGORY5_0_,
    commodity0_.DESCRIPTION as DESCRIPT6_0_,
    commodity0_.SELLER as SELLER7_0_ 
from
    COMMODITY commodity0_

很显然，控制台只会输出这么一段sql语句。

接下来我们在循环中输出Seller相关的属性:

@Test
public void findTest() {
    String hql = "from Commodity";

    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName());
        // 这里输出该商品对应商家的名称
        System.out.println(commodity.getSeller().getName());            
    }
}

这个时候我们再观察控制台的输出，

-- 进行商品的查询
Hibernate: 
    select
        commodity0_.ID as ID1_0_,
        commodity0_.NAME as NAME2_0_,
        commodity0_.PRICE as PRICE3_0_,
        commodity0_.UNIT as UNIT4_0_,
        commodity0_.CATEGORY as CATEGORY5_0_,
        commodity0_.DESCRIPTION as DESCRIPT6_0_,
        commodity0_.SELLER as SELLER7_0_ 
    from
        COMMODITY commodity0_;
-- 输出商品名称        
中式童装
-- 进行商家信息的查询
Hibernate: 
    select
        seller0_.ID as ID1_4_0_,
        seller0_.NAME as NAME2_4_0_,
        seller0_.TEL as TEL3_4_0_,
        seller0_.ADDRESS as ADDRESS4_4_0_,
        seller0_.WEBSITE as WEBSITE5_4_0_,
        seller0_.STAR as STAR6_4_0_,
        seller0_.BUSINESS as BUSINESS7_4_0_ 
    from
        SELLER seller0_ 
    where
        seller0_.ID=?;
-- 输出商家名称        
A服装店
女士套装
A服装店
男士西服
A服装店

可以发现这里因为要打印商家名称，所以在输出了商品名称之后，在输出商家名称的时候才去调用的商家相关的查询语句。

Select语句

通过Object[]形式返回

因为在不添加select子句的时候，默认返回的是整个映射对象，有时候我们并不需要那么多数据，所以就可以使用select子句了。
select子句中未指定返回数据类型，默认为Object[] 

/**
 * 只需要name,tel,address,star
 * 以Object[]形式返回
 */
@Test
public void selectTest() {
    String hql = "select s.name, s.tel, s.address, s.star from Seller s";
    Query query = session.createQuery(hql);
    List<Object[]> list = query.list();
    for (Object[] objects : list) {
        // 根据查询属性时候的顺序，这里也根据顺序来输出
        System.out.println("name:" + objects[0]);
        System.out.println("tel:" + objects[1]);
        System.out.println("address:" + objects[2]);
        System.out.println("star:" + objects[3]);
        System.out.println("----");
    }
}

由于上面所查询的属性超过了一个，所以用一个Object[]来接收算得上理所应当。但是如果只查询一个属性，还是用Object[]吗？ 并不是的，这里我们就需要使用Object来进行接收了

/**
 * 只需要name
 * 以Object形式返回
 */
@Test
public void selectTest2() {
    String hql = "select name from Seller";
    Query query = session.createQuery(hql);
    // 因为只查询了一个属性，所以这里使用Object。 如果依然使用Object[]会报错
    List<Object> list = query.list();
    for (Object object : list) {
        System.out.println("name: " + object);
    }
}

通过List形式返回

select子句还支持以List形式返回，使用方式如下:

/**
 * 以List形式返回
 */
@Test
public void selectTestList() {
    String hql = "select new list(s.name, s.tel, s.address) from Seller s";
    Query query = session.createQuery(hql);
    List<List> lists = query.list();
    for (List list : lists) {
        System.out.println("name: " + list.get(0));
        System.out.println("tel: " + list.get(1));
        System.out.println("address: " + list.get(2));
        System.out.println("---");
    }
}

以Map形式返回

/**
 * 以Map形式返回
 */
@Test
public void selectTestMap() {
    String hql = "select new map(s.name, s.tel, s.address) from Seller s";
    Query query = session.createQuery(hql);
    List<Map> maps = query.list();
    for (Map map : maps) {
        System.out.println("name: " + map.get("0"));
        System.out.println("tel: " + map.get("1"));
        System.out.println("address: " + map.get("2"));
    }
}

/**
 * 以Map形式返回，用属性别名取出
 */
@Test
public void selectTestMap2() {
    String hql = "select new map(s.name as name, s.tel as tel, s.address as address) from Seller s";
    Query query = session.createQuery(hql);
    List<Map> maps = query.list();
    for (Map map : maps) {
        System.out.println("name: " + map.get("name"));
        System.out.println("tel: " + map.get("tel"));
        System.out.println("address: " + map.get("address"));
    }
}

以自定义类型返回

首先需要去映射类中构建相应的构造方法，这里我们查询的是Seller，同时只查询了name,tel,address，所以在Seller.java中加入以下代码

public Seller(String name, String tel, String address) {
    this.name = name;
    this.tel = tel;
    this.address = address;
}

测试:

/**
 * 以自定义类型返回查询结果
 */
@Test
public void selectTestClass() {
    String hql = "select new Seller(s.name as name, s.tel as tel, s.address as address) from Seller s";
    Query query = session.createQuery(hql);
    List<Seller> sellers = query.list();
    for (Seller seller : sellers) {
        System.out.println("name: " + seller.getName());
        System.out.println("tel: " + seller.getTel());
        System.out.println("address: " + seller.getAddress());
    }
}

在自定义了构造器之后，依然需要保留默认的构造器。
不然会造成其他语句的错误，比如调用from Seller，因为没有了默认构造器，所以就无法正确的返回封装数据了

distinct返回不重复数据

这里的distinct同mysql中的一样作用，去除重复的数据

/**
 *使用distinct去除重复数据
 */
@Test
public void selectTestDistinct() {
//      String hql = "select s.star from Seller s";
    String hql = "select distinct s.star from Seller s";
    Query query = session.createQuery(hql);
    List<Object> list = query.list();
    for (Object object : list) {
        System.out.println("star: " + object);
    }
}

Where 子句

where子句是一个逻辑表达式。
设置查询条件，返回限制的查询结果。

比较运算

将持久化类的属性与给定的条件进行比较 ， 有以下比较运算符:
1. =、<>、<、>、>=、<=
2. null值判断 -> is [not] null

@Test
public void whereTest() {
    String hql = "from Commodity c where c.price > 400";
    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName() + "--" + commodity.getPrice());
    }
}

null值判断

@Test
public void nullTest() {
    // String hql = "from Commodity c where c.description is null";
    // 在HQL语句中可以这样(=、!=)判断是否为null，在SQL中是不可以的
    String hql = "from Commodity c where c.description = null";
    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName() + "--" + commodity.getDescription());
    }
}

范围运算

范围运算就是判断属性值是否在给定的范围内
1. [not] in (列表)
2. [not] between 值1 and 值2

@Test
public void betweenTest() {
    // 查询商家1和商家3的商品
    String hql = "from Commodity c where c.seller in (1, 3)";
    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName() + "--" + commodity.getSeller().getName() + "--" + commodity.getSeller().getId());
    }
}

字符串模糊匹配

  1. like关键字
  2. 通配符 %、_

%: 匹配任意个字符
_: 匹配一个字符

@Test
publicvoid likeTest() {
    // 查询名字中带有"童装"的商品
    String hql = "from Commodity c where c.name like '%童装%'";
    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName());
    }
}

逻辑运算符

  1. and(逻辑与)、or(逻辑或)
  2. not(逻辑非)
@Test
public void andOrTest() {
    // 查询商品价格在100 - 5000 同时 是与电脑相关的
    // String hql = "from Commodity c where c.price between 100 and 5000 and c.category like '%电脑%'";
    // 查询商品价格在100 - 5000 或者 是与电脑相关的
    String hql = "from Commodity c where c.price between 100 and 5000 or c.category like '%电脑%'";
    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName() + "--" + commodity.getPrice() + "--" + commodity.getCategory());
    }
}

集合运算

  1. is [not] empty 集合[不]为空，不包含任何元素
  2. member of 元素属于集合

这两个运算符都是HQL中特有的，代码在运行的时候，会将empty转换成exists；member of 会转换成in 

@Test
public void notEmptyTest() {
    // 查询订单明细不为空的订单
    String hql = "from Order o where o.orderItems is not empty";
    Query query = session.createQuery(hql);
    List<Order> list = query.list();
    for (Order order : list) {
        System.out.println(order.getCustomer() + "--" + order.getOrderItems().size());
    }
}

四则运算符

四则运算就是：加、减、乘、除了

@Test
public void operationsTest() {
    // 5个商品总价超过2000的
    String hql = "from Commodity c where c.price * 5 > 2000";
    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName() + "--" + commodity.getPrice());
    }
}

查询单个对象

  1. Query接口的uniqueResult方法
  2. where子句条件的设置，保证只有一个结果返回
@Test
public void uniqueResultTest() {
    // 查询男士西服
    String hql = "from Commodity c where c.name = '男士西服'";
    Query query = session.createQuery(hql);
    Commodity commodity = (Commodity) query.uniqueResult();
    System.out.println(commodity.getName());
}

Order by 子句

  1. 升序排序 ASC（默认）
  2. 降序排序 DESC
@Test
public void orderByTest() {
    // 根据价格降序排序
    String hql = "from Commodity c Order by c.price DESC";
    Query query = session.createQuery(hql);
    List<Commodity> list = query.list();
    for (Commodity commodity : list) {
        System.out.println(commodity.getName() + "--" + commodity.getPrice());
    }
}

相关资料

HQL数据查询基础
代码下载

whyalwaysmea
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于hql中部分关联字段为空时，不报错而直接查不出字段为空的记录
dac55300424的专栏
11-09 2655
select b.listNo,b.appGNo,b.trGno,b.complex,b.commName,b.commSpec,b.tradeUnit,b.tradeQty,b.unit,b.qty,b.note, c.listNo,c.appGNo,c.trGno,c.complex,c.commName,c.commSpec,c.tradeUnit,c.tr
HQL查询语言基础！
07-28
**HQL查询语言基础** HQL（Hibernate Query Language）是Hibernate框架中用于操作对象关系映射（ORM）的查询语言，它与SQL类似，但更专注于面向对象的查询。HQL允许开发者以类和对象的方式来编写查询，而不是直接...
HQL数据查询
白净垃圾桶-
08-31 535
HQL定义：Hibernate Query Language。是Hibernate框架提供的一种查询语言。HQL是面向对象的查询语言，其查询的主体是映射配置的持久化类及其属性。(注：SQL不是面向对象的查询语言，其主体是数据库表及表的字段) 实际上，hibernate框架会将编写好的HQL语句解析成相应的sql语句来完成最终的数据库查询操作。 HQL查询丰富灵活，是hibernate官方推荐的查
HQL查询
白云飞JAVA工作室
01-24 854
HQL查询：Criteria查询对查询条件进行了面向对象封装，符合编程人员的思维方式，不过HQL(Hibernate Query Lanaguage)查询提供了更加丰富的和灵活的查询特性，因此Hibernate将HQL查询方式立为官方推荐的标准查询方式，HQL查询在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装。完整的HQL语
Hibernate HQL基础 限定查询条件 .doc
03-09
HQL的基础包括了各种查询条件的设定，这些条件使得我们可以精确地定位和检索所需的数据。下面将详细介绍HQL中的一些关键操作和子句： 1. **Where 子句**： Where 子句是HQL中用于限制查询结果的关键部分，它接受一...
HQL查询语言基础
04-11
**HQL查询语言基础** HQL（Hibernate Query Language）是Hibernate框架中用于操作对象关系映射（ORM）的查询语言，它与SQL类似但更面向对象。HQL提供了丰富的功能来查询和操作数据库中的对象，使得开发人员可以更加...
常用易懂，易会HQL查询
06-26
通过理解并实践上述HQL的各个方面，你将能够轻松地在Hibernate项目中进行数据查询。记住，实践是最好的老师，多写多练，你会发现HQL其实并不复杂，而是非常直观和实用的。在实际开发中，结合IDE的自动补全功能，可以...
hibernate的HQL的模糊查询
05-20
二、HQL模糊查询基础 在HQL中，我们可以使用`like`关键字来进行模糊查询。`like`关键字后面可以跟一个包含通配符的字符串。常见的通配符有： - `%`：代表零个、一个或多个任意字符。 - `_`：代表一个任意字符。 ...
HQL条件查询
大块头
11-16 63
3、条件查询【重要】 * 可以采用拼字符串的方式传递参数 * 可以采用 ？来传递参数（索引从0开始） * 可以采用 :参数名 来传递参数 * 如果传递多个参数，可以采用setParamterList方法 * 在hql中可以使用数据库的函数，如：date_format 参见：SimpleConditionQueryTest.java ==============================...
hibernate查询之HQL
编程人生
05-28 88
上次我们一起学习了用Criteria进行相关的操作，但由于Criteria并不是Hibernate官方推荐的查询方式，我们也并不多用。现在我们来看一下官方推荐的HQL，一起学习一下它的强大。 说是HQL，也就是Hibernate查询语句，和SQL有什么区别呢？一个字母的区别，哈哈。 当然不是这样，HQL和SQL的区别在于思想的不同，HQL是用面向对象的方向进行查询，而SQL则是对数据库二...
hql查找为空的字段
06-24 491
字段名 = null 转载于:https://www.cnblogs.com/luoxiaolei/p/4597725.html
Hql简单使用
做一个会编程的人
06-11 741
一、简单属性查询 单一属性 多个属性，返回对象数组集合 多个属性，返回实体对象 普通别名使用 as命名别名 二、实体对象 三、条件查询 四、原生sql 五、外置命名 六、查询过滤器 七、分页查询 八、连接查询 九、统计查询
数据库查询，某个字段如果为空，则值按需要返回
kaidishi的专栏
07-24 3690
Hql查询，某个字段如何为空，则值按需求返回   如果parameter为null，则返回0 IFNULL(parameter,'0') 如果parameter为null，则返回"str"，并判断parameter中 '% parameterValue %’的数据 IFNULL(parameter,'str') like '%"+ parameterValue+"%' "
mysql查询为null或者空字符串
m0_57133702的博客
02-10 1万+
/** 用isnull判断是否为空：只有过滤条件 为null 的时候 ISNULL(exp) 函数的返回值为1 ，空串和有数据都为0 */ 查询test_id为 null 的所有数据(注意是 null)，返回结果中 把 test_id 为空字符串的数据不会显示出来 select * from test_table where isnull(test_id); 判断test_id 为 null 的另一种写法 select * from test_table where test_id is nu

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值