hql 订阅
HQL是Hibernate Query Language(Hibernate 查询语言)的缩写,提供更加丰富灵活、更为强大的查询能力;HQL更接近SQL语句查询语法。Hibernate 查询语言(HQL)是一种面向对象的查询语言,类似于 SQL,但不是去对表和列进行操作,而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对数据库进行操作。 展开全文
HQL是Hibernate Query Language(Hibernate 查询语言)的缩写,提供更加丰富灵活、更为强大的查询能力;HQL更接近SQL语句查询语法。Hibernate 查询语言(HQL)是一种面向对象的查询语言,类似于 SQL,但不是去对表和列进行操作,而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对数据库进行操作。
信息
外文名
Hibernate Query Language
缩    写
hql
特    点
对查询条件进行了面向对象封装
中文名
Hibernate 查询语言
接    近
SQL语句查询语法
hqlHQL的优点
Hibernate查询语言(HQL)与SQL(结构化查询语言)相同,但不依赖于数据库表。 我们在HQL中使用类名,而不是表名,它是数据库独立的查询语言。HQL有很多优点:
收起全文
精华内容
下载资源
问答
  • HQL

    2020-03-20 19:18:51
    HQL是Hibernate提供的一种面向对象的查询语言; 具体就是HQL是一种面向对象的查询语言,类似于 SQL,但不是去对表和列进行操作,而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对...

    HQL是Hibernate提供的一种面向对象的查询语言;

    具体就是HQL是一种面向对象的查询语言,类似于 SQL,但不是去对表和列进行操作,而是面向对象和它们的属性。 HQL 查询被 Hibernate 翻译为传统的 SQL 查询从而对数据库进行操作。

    HQL的优点和SQL的区别:

    面向对象,与数据库无关
    语法与SQL类是,比较容易学习

    HQL的用法:

    获得HibernateSession对象
    编写HQL语句
    调用Session的createQuery方法创建Query对象执行HQL语句
    如果HQL语句包含参数,则调用Query的setXxx方法为参数赋值
    调用Query对象的list等方法返回查询结果。

    HQL的一些常用示例
    1.无参查询所有

    String hql="select t from UserEntity t";
         //获得query对象,并执行hql语句
        Query query = session.createQuery(hql);
        //得到查询结果
         List<UserEntity> list =  query.list();
    

    2,有参查询

    String hql="from UserEntity where userName = ?";
         List<UserEntity > list =
           session.createQuery(hql)
                   .setParameter(0,"小白")//设置参数替换占位符
                   .list();
    

    3,有参查询部分列1

     String hql="select userName,pwd from  UserEntity ";
           //查询结果,每一个Object数组代表一行
            List<Object[]> list =
             session.createQuery(hql).list();
    

    4,有参查询部分列2

    String hql="select new map(userName,pwd) from TeacherEntity";
    		//查询结果,每个map集合代表结果的一行
            List<Map> list=
             session.createQuery(hql).list();
    

    5,模糊查询

    String hql="select new map(userName,pwd) " +
                    "from UserEntity where userName like ?";
            List<Map> list = session.createQuery(hql)
            				//传参时,需要加上通配符
                            .setParameter(0,"小%")
                            .list();
    

    6,连表查询

     String hql="select new map(s.studentName,t.teacherName,t.teacherClass) " +
                    "from StudentEntity s " +
                    " left join s.teacher t where t.teacherName=?";
             List<Map> list=
               session.createQuery(hql)
                       .setParameter(0,"陈老师")
                       .list();
    

    8,分页查询

    String hql="from UserEntity where teacherName like ?";
            List<TeacherEntity> list=
                    session.createQuery(hql)
                    .setParameter(0,"小%")
                    .setFirstResult(0) //起始下标
                    .setMaxResults(5) //每页显示的行数
                    .list();
    

    9,查询单个对象

     String hql="from UserEntity where userName like ?";
          TeacherEntity t=
                  (TeacherEntity) session.createQuery(hql)
                          .setParameter(0,"小%")
                          //返回查询的第一条结果
                          .uniqueResult();
    

    10,删除

      String hql="delete from UserEntity  where id = ?";
         int i =   session.createQuery(hql)
                    .setParameter(0,3)
                    .executeUpdate(); //执行修改、删除返回受影响的行数
    

    11,修改

     String hql="update UserEntityset userName=? where id = ?";
         int i= session.createQuery(hql)
                  .setParameter(0,"小青")
                  .setParameter(1,5)
                  //执行,并返回受影响行数
                  .executeUpdate();
    
    展开全文
  • hql

    千次阅读 2019-09-04 18:26:01
    HQL 是Hibernate Query Language的缩写 hql 与 sql 的区别/异同 hql sql 类名/属性 表名/列名 区分大小写,关键字不区分大小写 不区分大小写 别名 : ?,从下标0开始计算位置(hibernate5之后不支持) 别名...

    HQL

    是Hibernate Query Language的缩写

    hql 与 sql 的区别/异同

    hql sql
    类名/属性 表名/列名
    区分大小写,关键字不区分大小写 不区分大小写
    别名 : ?,从下标0开始计算位置(hibernate5之后不支持) 别名:?,从顺序1开始计算位置
    :命名参数 不支持:命名参数
    面向对象的查询语言 面向结构查询语言

    hql 语句介绍

    package com.hyf.xFive.test;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    import org.hibernate.query.Query;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    import com.hyf.four.entity.Book;
    import com.hyf.two.util.SessionFactoryUtils;
    
    public class HqlTest {
    	private Session session;
    	private Transaction transaction;
    	
    	@Before
    	public void before() {
    		session = SessionFactoryUtils.openSession();
    		transaction = session.beginTransaction();
    	}
    	
    	@After
    	public void after() {
    		transaction.commit();
    		session.close();
    	}
    	
    	/**
    	 * 返回对象(多个)
    	 */
    	@Test
    	public void testList1() {
    		Query query = session.createQuery("from Book");
    		List<Book> list = query.list();
    		for (Book b : list) {
    			System.out.println(b);
    		}
    	}
    	
    	/**
    	 * 返回单个列段,用字符串就可以接受
    	 */
    	@Test
    	public void testList2() {
    		Query query = session.createQuery("select b.bookName as ss from Book b");
    		List<String> list = query.list();
    		for (String b : list) {
    			System.out.println(b);
    		}
    	}
    	
    	/**
    	 * 查两个列段及以上,默认返回的是Object【】
    	 */
    	@Test
    	public void testList3() {
    		Query query = session.createQuery("select b.bookId,b.bookName as ss from Book b");
    		List<Object[]> list = query.list();
    		for (Object[] b : list) {
    			System.out.println(Arrays.toString(b));
    		}
    	}
    	
    	/**
    	 * 注意map是函数,所以不区分大小写,返回的是map集合
    	 */
    	@Test
    	public void testList4() {
    		Query query = session.createQuery("select new mAp(b.bookId,b.bookName) from Book b");
    		List<Map> list = query.list();
    		for (Map b : list) {
    			System.out.println(b);
    		}
    	}
    	
    	/**
    	 * 查两个列段及以上,也可返回对象,前提是有对应的构造函数
    	 */
    	@Test
    	public void testList5() {
    		Query query = session.createQuery("select new Book(b.bookId,b.bookName) from Book b");
    		List<Book> list = query.list();
    		for (Book b : list) {
    			System.out.println(b);
    		}
    	}
    	
    	/**
    	 * HQL语句支持占位符
    	 */
    	@Test
    	public void testList6() {
    //		Query query = session.createQuery("from Book where bookId = :bookId");
    //		query.setParameter("bookId", 1);
    //		Book b = (Book) query.getSingleResult();
    //		System.out.println(b);
    		
    		Query query = session.createQuery("from Book where bookId in (:bookIds)");
    		// 查询id 为 1 , 2,4
    		// 传数组
    //		query.setParameterList("bookIds", new Integer[] {1,2,4});
    		// 传集合
    		List<Integer> params = new ArrayList<Integer>();
    		params.add(1);
    		params.add(2);
    		params.add(4);
    		query.setParameterList("bookIds", params);
    		List<Book> list = query.list();
    		for (Book b : list) {
    			System.out.println(b);
    		}
    	}
    	
    	/**
    	 * HQL支持连接查询
    	 */
    	@Test
    	public void testList7() {
    		Query query = session.createQuery("select o.orderNo,oi.quantity from Order o,OrderItem oi where o = oi.order");
    		List<Object[]> list = query.list();
    		for (Object[] b : list) {
    			System.out.println(Arrays.toString(b));
    		}
    	}
    	
    	/**
    	 * HQL支持聚合函数
    	 */
    	@Test
    	public void testList8() {
    		Query query = session.createQuery("select count(*) from Book");
    		Long singleResult = (Long) query.getSingleResult();
    		System.out.println(singleResult);
    	}
    	
    	/**
    	 * HQL分页
    	 */
    	@Test
    	public void testList9() {
    		Query query = session.createQuery("from Book");
    		query.setFirstResult(2);
    		query.setMaxResults(3);
    		List<Book> list = query.list();
    		for (Book b : list) {
    			System.out.println(b);
    		}
    	}
    }
    
    

    query.list(); 查询多条数据
    query.getSingleResult() 查询多条数据单条

    在这里插入图片描述

    通用查询hql baseDao

    版本一

    public  List<Book> list(Book book,PageBean pageBean){
    		Session session = SessionFactoryUtils.openSession();
    		String hql = "from Book where 1=1";
    		String bname = book.getBookName();
    		if(StringUtils.isNotBlank(bname)) {
    			hql +=" and bookName like :bookName";
    		}
            		
    		Query query = session.createQuery(hql );
    		
    		// 当 bname 不等于空的时候赋值
    		if(StringUtils.isNotBlank(bname)) {
    			query.setParameter("bookName", bname);
    		}
    		
    		// 分页
    		if(pageBean !=null && pageBean.isPagination()) {
    			// 设置pageBean 起始下标
    			query.setFirstResult(pageBean.getStartIndex());
    			query.setMaxResults(pageBean.getRows());
    		}
    		List list = query.list();
    		
    		return list;
    	}
    	
    

    问题:每增加一个查询就需要写一个这种语句,如果数量过多的话,导致重复代码过多。
    在这里插入图片描述

    版本二
    通用 beasDao

    package com.hyf.xFive.util;
    
    import java.util.Collection;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    
    import org.hibernate.Session;
    import org.hibernate.query.Query;
    
    /**
     * 基于hql语句的通用查询通用工具类 
     *      1、需要给拼接的hql语句的命名参数赋值(可以简化的) 
     *      2、分页(可以简化)
     *       
     *      基于sql的分页的查询的做法
     *         1、首先要查询出符合条件的总记录数
     *         2、返回符合条件的记录
     *      参数:sql ,pageBean,Class clz
     *       1、 countSql = select count(*) from (sql) t;
     *       2、 pageSql = sql + " limit " +start +" , " +rows
     *       
     *      基于hql的分页的查询的做法
     *        hql =          from Book where bookName like "%xxx%"
     *        hql = select * from Book where bookName like "%圣墟%"
     *        1、countHql = select count(*) hql  
     *        
     *          
     * @author 17628
     *
     */
    public class BeasDao {
    
    	/**
    	 * @param query  里面包含了带有参数的hql 语句,需要等待赋值
    	 *       "from Book where 1=1  and bookName like :bookName
    	 * @param map  
    	 *        =request.getParameterMap();
    	 */      
    	public void setParam(Query query, Map<String, Object> paramMap) {
             if(paramMap !=null && paramMap.size()!=0) {
            	  // 遍历 paramMap 集合 得到前台传来的数据
            	 Set<Entry<String, Object>> entrySet = paramMap.entrySet();
            	 for (Entry<String, Object> entry : entrySet) {
    			  // 遍历之后,给 query 赋值
            		 String key = entry.getKey();
            		 Object value = entry.getValue();
            		 // 我们这里要考虑以下 传过来的是数组 还是集合
            		 if(value instanceof Object[]) {
            			 // 当 value 为数组时
            			 query.setParameter(key, (Object [])value);
            		 }else if(value instanceof Collection){
            			// 当 value 为集合时
            			 query.setParameter(key, (Collection)value);
            		 }else {
            			 // 普通字符串
            			 query.setParameter(key, value);
            		 }
    			}
             }
    	}
    	
    	
    	/**
    	 *  拼装符合条件的总记录数
    	 * 2、countHql = select count(*) hql  
    	 *   hql 可以能为以下两种情况
    	 *       hql =          from Book where bookName like "%xxx%"
     *           hql = select * from Book where bookName like "%圣墟%"
    	 *       所以通过截取得到  from和后面的条件
    	 * 
    	 * @param hql
    	 * @return
    	 */
    	public String getCountSql(String hql) {
    		// toUpperCase()  转大写  。因为hql 区分大小写 ,我们干脆把hql语句转成 大写
    		// indexOf()      取 FROM 的下标
    		int fromIndex = hql.toUpperCase().indexOf("FROM");
    		return "select count(*)"+hql.substring(fromIndex);
    	}
    	
    	
    	/**
    	 * 基于hql通用查询方法
    	 * 
    	 * @param hql       最终传来的 hql 语句
    	 * @param pageBean  分页
    	 * @param paramMap  =request.getParameterMap(); 前台传来的 值
    	 * @param session   创建 Query 对象
    	 * @return
    	 */
    	public List  executeQuery(String hql,PageBean pageBean,Map<String,Object> paramMap,Session session) {
    		List list = null;
    		Query query = null;
    		if(pageBean != null && pageBean.isPagination()) {
    			// 获取查询的总数量
    			String countHql =getCountSql(hql);
    			Query createQuery = session.createQuery(countHql);
    			this.setParam(createQuery, paramMap);
    			//将总行数放入PageBean对象
    			pageBean.setTotal(createQuery.getSingleResult().toString());
    			
    			// 返回符合条件的记录
    			query = session.createQuery(hql);
    			//给预定于的hql语句的命名参数赋值。有多少赋多少
    			this.setParam(query, paramMap);
    			//设置开始位置(下标从0开始)
    			query.setFirstResult(pageBean.getStartIndex());
    			//这是偏移量,就是一页展示几条数据
    			query.setMaxResults(pageBean.getRows());
    			list=query.list();
    		}else {
    			// 不分页
    			query=session.createQuery(hql);
    			this.setParam(query, paramMap);
    			list=query.list();
    		}
    		return list;
    		
    	}
    }
    
    

    BookDao
    它需要继承 BaseDao

    public  List<Book> listPlus(Book book,PageBean pageBean){
    		Session session = SessionFactoryUtils.openSession();
    		String hql = "from Book where 1=1";
    		String bname = book.getBookName();
    		
    //		这个是jsp 自动传递过来的,不与要手写,模拟一下
    		Map<String, Object> map = new HashMap<String, Object>();
    		
    		if(StringUtils.isNotBlank(bname)) {
    			hql +=" and bookName like :bookName";
    			map.put("bookName", bname);
    		}
    		
    		List list = super.executeQuery(hql, pageBean, map, session);
    		session.close();
    		return list;
    	}
    

    JUnit 测试

    	@Test
    	public void testList11() {
            Book b = new Book();
            PageBean pageBena = new PageBean();
            pageBena.setPage(3);
         //   b.setBookName("%圣墟%");
            List<Book> list = this.bookDao.listPlus(b, pageBena);
            for (Book book : list) {
    			System.out.println(book);
    		}
    	}
    

    测试结果:
    在这里插入图片描述

    展开全文
  • Hql

    2018-10-29 20:01:37
    什么是hql HQL是Hibernate Query Language的缩写 查全部 hql和sql区别/异同 HQL SQL 类名/属性 表名/列名 区分大小写,关键字不区分大小写 不区分大小写 别名 ...
    1. 什么是hql
      HQL是Hibernate Query Language的缩写

      查全部

    2. hql和sql区别/异同
      HQL SQL
      类名/属性 表名/列名
      区分大小写,关键字不区分大小写 不区分大小写
      别名 别名
      ?,从下标0开始计算位置(hibernate5之后不支持) ?,从顺序1开始计算位置
      :命名参数 不支持:命名参数
      面向对象的查询语言 面向结构查询语言

    3. 处理返回的结果集
      3.1 单个对象
      select没有逗号
      3.2 Object[]
      b.bookId, b.bookName
      3.3 Map
      new Map(b.bookId as bid, b.bookName as bname)
      3.4 new 构造方法(attr1,attr2)
      new Book(b.bookId, b.price)
      在这里插入图片描述

    在这里插入图片描述

    1. hql中使用占位符
      4.1 ?占位符
      从下标0开始计算位置
      hibernate5之后不再支持?占位符

    在这里插入图片描述

    1. 聚合函数
      sum
      avg
      max
      min
      count

    7分页

    在这里插入图片描述

    展开全文
  • HQL语句

    万次阅读 2020-09-09 10:10:27
    hql常用查询语句 // HQL: Hibernate Query Language. // 特点: // >> 1,与SQL相似,SQL中的语法基本上都可以直接使用。 // >> 2,SQL查询的是表和表中的列;HQL查询的是对象与对象中的属性。 // >&...

    hql常用查询语句
    // HQL: Hibernate Query Language.
    // 特点:
    // >> 1,与SQL相似,SQL中的语法基本上都可以直接使用。
    // >> 2,SQL查询的是表和表中的列;HQL查询的是对象与对象中的属性。
    // >> 3,HQL的关键字不区分大小写,类名与属性名是区分大小写的。
    // >> 4,SELECT可以省略.

    // 1,简单的查询,Employee为实体名而不是数据库中的表名(面向对象特性)
    hql = “FROM Employee”;
    hql = “FROM Employee AS e”; // 使用别名
    hql = “FROM Employee e”; // 使用别名,as关键字可省略

    // 2,带上过滤条件的(可以使用别名):Where
    hql = “FROM Employee WHERE id<10”;
    hql = “FROM Employee e WHERE e.id<10”;
    hql = “FROM Employee e WHERE e.id<10 AND e.id>5”;

    // 3,带上排序条件的:Order By
    hql = “FROM Employee e WHERE e.id<10 ORDER BY e.name”;
    hql = “FROM Employee e WHERE e.id<10 ORDER BY e.name DESC”;
    hql = “FROM Employee e WHERE e.id<10 ORDER BY e.name DESC, id ASC”;

    // 4,指定select子句(不可以使用select *)
    hql = “SELECT e FROM Employee e”; // 相当于"FROM Employee e"
    hql = “SELECT e.name FROM Employee e”; // 只查询一个列,返回的集合的元素类型就是这个属性的类型
    hql = “SELECT e.id,e.name FROM Employee e”; // 查询多个列,返回的集合的元素类型是Object数组
    hql = “SELECT new Employee(e.id,e.name) FROM Employee e”; // 可以使用new语法,指定把查询出的部分属性封装到对象中

    // 5,执行查询,获得结果(list、uniqueResult、分页 ) Query query = session.createQuery(“FROM Employee e WHERE id<3”);
    query.setFirstResult(0);
    query.setMaxResults(10); // 等同于 limit 0,10
    //两种查询结果list、uniqueResult
    // List list = query.list(); // 查询的结果是一个List集合
    // Employee employee = (Employee) query.uniqueResult();// 查询的结果是唯一的一个结果,当结果有多个,就会抛异常

    // 6,方法链
    List list = session.createQuery(//
    “FROM Employee e”)//
    .setFirstResult(0)//
    .setMaxResults(10)//
    .list();

    // 7,聚集函数:count(), max(), min(), avg(), sum()
    hql = “SELECT COUNT(*) FROM Employee”; // 返回的结果是Long型的
    hql = “SELECT min(id) FROM Employee”; // 返回的结果是id属性的类型

    //8,分组: Group By … Having
    hql = “SELECT e.name,COUNT(e.id) FROM Employee e GROUP BY e.name”;
    hql = “SELECT e.name,COUNT(e.id) FROM Employee e GROUP BY e.name HAVING count(e.id)>1”;
    hql = “SELECT e.name,COUNT(e.id) FROM Employee e WHERE id<9 GROUP BY e.name HAVING count(e.id)>1”;
    hql = "SELECT e.name,COUNT(e.id) " + //
    "FROM Employee e " + //
    "WHERE id<9 " + //
    "GROUP BY e.name " + //
    "HAVING count(e.id)>1 " + //
    “ORDER BY count(e.id) ASC”;
    hql = "SELECT e.name,COUNT(e.id) AS c " + //
    "FROM Employee e " + //
    "WHERE id<9 " + //
    "GROUP BY e.name " + //
    "HAVING count(e.id)>1 " + // 在having子句中不能使用列别名
    “ORDER BY c ASC”; // 在orderby子句中可以使用列别名

    // 9,连接查询 / HQL是面向对象的查询
    //>> 内连接(inner关键字可以省略)
    hql = “SELECT e.id,e.name,d.name FROM Employee e JOIN e.department d”;
    hql = “SELECT e.id,e.name,d.name FROM Employee e INNER JOIN e.department d”;
    //>> 左外连接(outer关键字可以省略)
    hql = “SELECT e.id,e.name,d.name FROM Employee e LEFT OUTER JOIN e.department d”;
    //>> 右外连接(outer关键字可以省略)
    hql = “SELECT e.id,e.name,d.name FROM Employee e RIGHT JOIN e.department d”;
    //可以使用更方便的方法
    hql = “SELECT e.id,e.name,e.department.name FROM Employee e”;

    // 10,查询时使用参数
    // >> 方式一:使用’?'占位
    hql = “FROM Employee e WHERE id BETWEEN ? AND ?”;
    List list2 = session.createQuery(hql)//
    .setParameter(0, 5)// 设置参数,第1个参数的索引为0。
    .setParameter(1, 15)//
    .list();

    // >> 方式二:使用变量名
    hql = “FROM Employee e WHERE id BETWEEN :idMin AND :idMax”;
    List list3 = session.createQuery(hql)//
    .setParameter(“idMax”, 15)//
    .setParameter(“idMin”, 5)//
    .list();

    // 当参数是集合时,一定要使用setParameterList()设置参数值
    hql = “FROM Employee e WHERE id IN (:ids)”;
    List list4 = session.createQuery(hql)//
    .setParameterList(“ids”, new Object[] { 1, 2, 3, 5, 8, 100 })//
    .list();

    // 11,update与delete,不会通知Session缓存
    // >> Update
    int result = session.createQuery(//
    “UPDATE Employee e SET e.name=? WHERE id>15”)//
    .setParameter(0, “无名氏”)//
    .executeUpdate(); // 返回int型的结果,表示影响了多少行。
    // >> Delete
    int result1 = session.createQuery(//
    “DELETE FROM Employee e WHERE id>15”)//
    .executeUpdate(); // 返回int型的结果,表示影响了多少行。

    展开全文
  • hql ppt Hql PPt

    2011-12-30 09:57:49
    Hql PPt Hql PPt
  • HQL 详解 HQL查询

    2013-02-21 03:39:01
    Criteria查询对查询条件进行了面向对象封装,符合编程人员的思维方式,不过HQL(Hibernate Query Lanaguage)查询提供了更加丰富的和灵活的查询特性,因此Hibernate将HQL查询方式立为官方推荐的标准查询方式,HQL查询...
  • HQL语句 HQL语句

    2009-01-14 14:33:23
    HQL语句 HQL语句 HQL语句 HQL语句 HQL语句
  • hibernateのHQL

    2021-01-19 21:54:42
    Hql与Sql 1、HQL是面向对象的,所以HQL与数据库无关 2、HQL最终也会生成SQL,也就是说 HQL使用范围是<SQL的范围 3、HQL是由query对象获得。 hql sql 面向对象 面向结构(表) 操作的是实体类 ,类属性 表,...
  • Hibernate HQL

    2021-02-25 17:26:03
    HQL:Hibernate Query Language,是Hibernate框架提供的一种查询机制,和SQL类似,不同的是HQL是面向对象的查询语句,让开发者能够以面向对象的思想来编写查询语句,对java来说十分友好。HQL不直接参与数据库的交互,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,858
精华内容 9,543
关键字:

hql