HQL数据查询基础（三）

       继上回 （HQL数据查询基础（二）），针对“网上商店”这个例子，来讲解一些HQL简单的子句用法。

（以下的所有测试方法均在 MyTest.java 测试类（在上文上有提到）中添加）

from子句

1）HQL语句最简形式；

2）from指定了HQL语句查询主体——持久化类及其属性

from子句中持久化类的引用

1）不需要引入持久化类的全限定名，直接引入类名；

2）auto-import（自动引入）缺省情况。

测试from子句的使用——获取customer表中的所有客户信息：

<span style="font-size:18px;">@Test    public void testFromClause1() {        String hql = " from Customer ";        //创建Query实例对象        Query query = session.createQuery(hql);        List<Customer> customers = query.list();        for(Customer customer : customers) {            System.out.println("name: " + customer.getName());        }    }</span>

测试能否通过 商品对象 获得 商家信息：

<span style="font-size:18px;">/**     * 测试能否通过 商品对象 获取 商家信息     */    @Test    public void testFromClause2() {        String hql = " from Commodity ";        Query query = session.createQuery(hql);        List<Commodity> commodities = query.list();        for (Commodity c : commodities) {            System.out.println("name: " + c.getName());            System.out.println("seller's name: " + c.getSeller().getName());        }    }</span>

       Hibernate中默认是“懒”加载状态，只有需要到某些关联信息才进行查询。在这个例子中，我们先查询到所有商品信息，根据商品信息获取商家信息，获取商家信息的时候Hibernate才发起查询，并不是在查询到商品信息的同时也查询了商家信息。Hibernate做了延迟加载。

from子句中别名的应用

1）为被查询的类指定别名；

2）在HQL语句其他部分通过别名引用该类；

3）别名命名习惯：一般与持久类类名相同，使用小写。如：from Seller 中 Seller 别名可以为 seller，为了简洁，别名也可以取名为 s。在简洁的同时，需要保证代码的可读性。

具体如： from Seller as seller 或 from Seller as s 或 from Seller seller 或 from Seller s（as 关键字可以省略）

select子句

1）select子句中未指定返回数据类型，默认为Object[]；（注意：当查询的字段只有一个时，返回的数据类型就不再是 Object[]，而是Object）

测试select子句的Object[] 返回数据类型：

<span style="font-size:18px;">/**     * 1. name 2.tel 3.address 4.star     */    @Test    public void testSelectClauseObjectArray() {        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[] objs : list) {            System.out.println("name: " + objs[0]);            System.out.println("tel: " + objs[1]);            System.out.println("address: " + objs[2]);            System.out.println("star: " + objs[3]);        }        System.out.println();        System.out.println("特殊实例：");        //如果查询的字段只有一个的话，那么其返回类型是 Object 而不是Object[]。        String hql2 = "select s.name from Seller s ";        Query query2 = session.createQuery(hql2);        List<Object> list2 = query2.list();        for(Object objs : list2) {            System.out.println("name: " + objs);        }    }</span>

2）以List形式返回查询结果——select子句中使用new list指定；

测试select子句的 List 返回数据类型：

<span style="font-size:18px;">    @Test    public void testSelectClauseList() {        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));        }    }</span>

3）以Map形式返回查询结果——select子句中使用new map指定，key值为索引值，字符串类型；

测试select子句的 Map返回数据类型：

<span style="font-size:18px;">    @Test    public void testSelectClauseMap() {        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"));        }        //除了通过序号来获取查询结果外，还可以使用别名来获取        String hql2 = "select new map(s.name as name, s.tel as tel, s.address as address) from Seller s";        Query query2 = session.createQuery(hql2);        List<Map> maps2 = query2.list();        for(Map map : maps2) {            System.out.println("name: " + map.get("name"));            System.out.println("tel: " + map.get("tel"));            System.out.println("address: " + map.get("address"));        }    }</span>

4）以自定义类型返回查询结果——持久化类中定义对应的构造器，构造器的参数就是我们选择返回的属性信息；select子句中调用定义的构造器来完成相应的查询，以自定义类型来返回查询的结果

测试select子句中以自定义类型返回查询结果：

        需要我们在查询类中添加自定义的构造方法，本次查询的类为 Seller类，我们需要在Seller类中自定义构造方法，而构造方法中的参数就是我们需要查询返回的信息：

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

测试方法如下：

@Test    public void testSelectClauseSelf() {        String hql = "select new Seller(s.name, s.tel, s.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());        }    }

注：当我们自定义了构造方法之后，还需要定义无参的构造方法吗？答案是肯定的。我们先来回顾一下之前定义的一个测试方法testSeller：

    @Test    public void testSeller() {        String hql = " from Seller s";        //创建Query实例对象        Query query = session.createQuery(hql);        List<Seller> sellers = query.list();        for(Seller seller : sellers) {            System.out.println(seller);        }    }

这里并未使用到select子句，那么默认返回的是所有Seller的所有属性信息，它此时调用的无参构造方法。如果我们不提供默认的无参构造方法的话，执行上面的测试方法，将出现 没有找到 Seller 实体的错误提示。

所以我们需要在自定义构造方法后，在类中同样增加无参的构造方法。

distinct 关键字

使用distinct关键字去除查询结果中的重复元素

测试使用distinct关键字，消除结果集中重复的元素：

    @Test    public void testDistinct() {        String hql = "select distinct c.sex from Customer c";        Query query = session.createQuery(hql);        List<Object> list = query.list();        for(Object obj : list) {            System.out.println(obj);        }    }

where子句

我们可以通过where子句设置查询条件，限制返回结果。

（1）比较运算

1. = 、<> 、< 、> 、>= 、<=

2.null值判断——is [not] null，在HQL中可使用 = null 或 <> null 来表示 is [not] null

测试使用比较运算符：

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

测试null值判断：

    @Test    public void testWhere2() {        //is null 的判断        //String hql = " from Commodity c where c.description is null";        //String hql = " from Commodity c where c.description = null";        //is not null 的判断        //String hql = " from Commodity c where c.description is not null";        String hql = " from Commodity c where c.description <> null";        Query query = session.createQuery(hql);        List<Commodity> commodities = query.list();        for(Commodity c : commodities) {            System.out.println("name: " + c.getName());            System.out.println("description: " + c.getDescription());        }    }

（2）范围运算

1. [not] in(列表)；

2. [not] between 值1 and 值2

测试：

    @Test    public void testWhere3() {        //String hql = " from Customer c where c.age in(20, 40)";        //String hql = " from Customer c where c.age not in(20, 40)";        //String hql = " from Customer c where c.age between 20 and 40";        String hql = " from Customer c where c.age not between 20 and 40";        Query query = session.createQuery(hql);        List<Customer> customers = query.list();        for(Customer c : customers) {            System.out.println("name: " + c.getName());            System.out.println("age: " + c.getAge());        }    }

（3）字符串模式匹配

1、like关键字；

2、通配符 %、_ （%：任意个字符；_：一个字符）

测试：

@Test    public void testWhere4() {        //String hql = " from Customer c where c.name like '张_'";        String hql = " from Customer c where c.address like '%北京%'";        Query query = session.createQuery(hql);        List<Customer> customers = query.list();        for(Customer c : customers) {            System.out.println("name: " + c.getName());            System.out.println("address: " + c.getAddress());        }    }

（4）逻辑运算

1、and（逻辑与）、or（逻辑或）

2、not（逻辑非）

测试：

    @Test    public void testWhere5() {        //String hql = " from Commodity c where c.price between 100 and 5000 and c.category like '%电脑%'";        String hql = " from Commodity c where c.price between 100 and 5000 or c.category like '%电脑%'";        Query query = session.createQuery(hql);        List<Commodity> commodities = query.list();        for(Commodity c : commodities) {            System.out.println("name: " + c.getName());            System.out.println("category: " + c.getCategory());            System.out.println("price: " + c.getPrice());        }    }

（5）集合运算

1、is [not] empty 集合[不]为空，不包含任何元素；

2、member of 元素属于集合；

测试：

    @Test    public void testWhere6() {        //查询订单信息不为空的有效订单        String hql = " from Order o where o.orderItems is not empty";        Query query = session.createQuery(hql);        List<Order> orders = query.list();        for(Order order : orders) {            System.out.println(order.getCustomer().getName());            System.out.println(order.getAmount());            System.out.println(order.getTradeDate());        }    }

（6）四则运算

1、HQL语句中也可以使用 + - x / 四则运算

2、四则运算可以在where子句和select子句中使用

测试：

    @Test    public void testWhere7() {        String hql = " from Commodity c where c.price * 5 > 3000";        Query query = session.createQuery(hql);        List<Commodity> commodities = query.list();        for(Commodity c : commodities) {            System.out.println("name: " + c.getName());            System.out.println("price: " + c.getPrice() * 5);        }    }

（7）查询单个对象

1、Query接口的uniqueResult方法；

2、where子句条件的设置，我们需要确保where子句设置的条件查询出来的结果只有一条数据或没有数据，否则使用uniqueResult方法过程中会抛出异常 org.hibernate.NonUniqueResultException: query did not return a unique result，中止运行。

测试：

    @Test    public void testWhere8() {        //String hql = " from Customer c where c.name = '张三'";        String hql = " from Customer c where c.age > 20";        Query query = session.createQuery(hql);        Customer c = (Customer) query.uniqueResult();        System.out.println(c.getName());    }

排序——order by子句

使用order by子句对查询结果排序

1、升序排序 asc；2、降序排序 desc；

测试：

    @Test    public void testOrderBy() {        //String hql = " from Commodity order by price asc";        //String hql = " from Commodity order by price desc";        String hql = " from Commodity order by seller.id asc, price desc, name asc";        Query query = session.createQuery(hql);        List<Commodity> commodities = query.list();        for(Commodity c : commodities) {            System.out.println("name: " + c.getName());            System.out.println("sellerId: " + c.getSeller().getId());            System.out.println("sellerName: " + c.getSeller().getName());            System.out.println("price: " + c.getPrice());        }    }