hibernate中hql查询

最新推荐文章于 2023-05-20 18:22:17 发布
最新推荐文章于 2023-05-20 18:22:17 发布
阅读量2.2w 收藏 51
点赞数 7
分类专栏： hibernate 文章标签： hibernate query string object user delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaerfeng/article/details/6969649
版权 
package com.tudou.hibernates.t1;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class TestGetHql {
	private static Configuration cfg = new Configuration().configure();
	private static SessionFactory fac = cfg.buildSessionFactory();
	private static Session son = fac.openSession();

	// hql普通查询 Card为类名，不是表名，可以写全路径
	public static void from() {
		String hql = "from Card";
		Query query = son.createQuery(hql);
		List<Card> cards = query.list();
		for (Card c : cards) {
			System.out.println(c.getCardName());
			System.out.println(c.getCreateDate());
		}
	}

	// 条件查询 where
	public static void where() {
		String hql = "from Card where cardName='三国无双'";
		Query query = son.createQuery(hql);
		List<Card> cardss = query.list();
		for (Card c : cardss) {
			System.out.println(c.getCardName());
			System.out.println(c.getCreateDate());
		}
	}

	// 模糊查询 like
	public static void like() {
		String hql = "from Card where cardName like '%世%'";
		Query query = son.createQuery(hql);
		List<Card> cards = query.list();
		for (Card c : cards) {
			System.out.println(c.getCardName());
			System.out.println(c.getCreateDate());
		}
	}

	// 逻辑条件查询 >
	public static void gt() {
		String hql = "from Card c where c.createDate >'2011-08-08'";
		Query query = son.createQuery(hql);
		List<Card> cards = query.list();
		for (Card c : cards) {
			System.out.println(c.getCardName());
			System.out.println(c.getCreateDate());
		}
	}

	// 逻辑条件查询 between and 此处用了别名，省略了as关键字
	public static void between() {
		String hql = "from Card c where c.createDate between '2011-08-08' and '2022-11-11'";
		Query query = son.createQuery(hql);
		List<Card> cards = query.list();
		for (Card c : cards) {
			System.out.println(c.getCardName());
			System.out.println(c.getCreateDate());
		}
	}

	// 逻辑多条件查询and
	public static void and() {
		String hql = "from Card c where c.createDate between '2011-01-08' and '2022-11-11' and c.cardName like '%世%'";
		Query query = son.createQuery(hql);
		List<Card> cards = query.list();
		for (Card c : cards) {
			System.out.println(c.getCardName());
			System.out.println(c.getCreateDate());
		}
	}

	// update 更新
	public static void update() {
		String hql = "update Card as c set c.createDate='2011-03-03' where c.cardType.cardTypeId=3";
		Query query = son.createQuery(hql);
		int num = query.executeUpdate();
		System.out.println(num + "行被更新。。。");
	}

	// delete删除
	public static void delete() {
		String hql = "delete from  Card as c where c.createDate='2011-03-04'";
		Query query = son.createQuery(hql);
		int num = query.executeUpdate();
		System.out.println(num + "行被删除。。。");
	}

	// 单个属性查询
	public static void simpleProperty() {
		String hql = "select c.cardName from  Card as c where c.cardType.cardTypeId=1";
		Query query = son.createQuery(hql);
		List<String> name = query.list();
		for (String s : name) {
			System.out.println(s);
		}
	}

	// 多个属性查询 其中cardTypeName直接通过card对象的cardType对象获得，省去了使用普通的sql语句必须多表连接查询的麻烦
	public static void mulProperty() {
		String hql = "select c.cardName,c.cardType.cardTypeName,c.createDate from  Card as c where c.cardType.cardTypeId=1";
		Query query = son.createQuery(hql);
		List<Object[]> obj = query.list();
		for (Object[] o : obj) {
			System.out.println(o[0] + "\t" + o[1] + "\t" + o[2]);
		}
	}

	// 多个属性查询 面向对象方式
	public static void orientedObject() {
		String hql = "select new Card(c.cardName,c.createDate) from  Card as c";
		Query query = son.createQuery(hql);
		List<Card> cards = query.list();
		for (Card c : cards) {
			System.out.println(c.getCardName() + "\t" + c.getCreateDate());
		}
	}

	// 函数查询
	public static void function() {
		String hql = "select count(*),max(c.createDate) from  Card as c";
		Query query = son.createQuery(hql);
		List<Object[]> oo = query.list();
		for (Object[] o : oo) {
			System.out.println("总记录数：" + o[0] + "\t最新日期为：" + o[1]);
		}
	}

	// 排序
	public static void orderBy() {
		String hql = "from  Card as c order by c.createDate desc";
		Query query = son.createQuery(hql);
		List<Card> cards = query.list();
		for (Card c : cards) {
			System.out.println(c.getCardName() + "\t" + c.getCreateDate());
		}
	}

	// 分组
	public static void groupBy() {
		String hql = "from  Card as c group by c.cardType.cardTypeId";
		Query query = son.createQuery(hql);
		List<Card> cards = query.list();
		for (Card c : cards) {
			System.out.println(c.getCardName() + "\t" + c.getCreateDate());
		}
	}

	// 单个对象查询 呵呵，奇怪吧，对象可以查询出来
	public static void simpleObject() {
		String hql = "select c.cardType from  Card as c";
		Query query = son.createQuery(hql);
		query.setMaxResults(1);// 必须在查询之前指定，使其返回单个对象
		CardType cardType1 = (CardType) query.uniqueResult();
		System.out.println(cardType1.getCardTypeName() + "\t"
				+ cardType1.getCreateDate());
	}

	// 按照命令行参数 格式为： :参数名
	public static void parameter() {
		String hql = "select c.cardType from  Card as c where c.cardType.cardTypeId=:id";
		Query query = son.createQuery(hql);
		query.setParameter("id", 1);
		query.setMaxResults(1);// 必须在查询之前指定，使其返回单个对象
		CardType cardType = (CardType) query.uniqueResult();
		System.out.println(cardType.getCardTypeName() + "\t"
				+ cardType.getCreateDate());
	}

	// 按照参数位置 从0开始
	public static void parameterPosition() {
		String hql = "select c.cardType from  Card as c where c.cardType.cardTypeId=?";
		Query query = son.createQuery(hql);
		query.setParameter(0, 1);
		query.setMaxResults(1);// 必须在查询之前指定，使其返回单个对象
		CardType cardType = (CardType) query.uniqueResult();
		System.out.println(cardType.getCardTypeName() + "\t"
				+ cardType.getCreateDate());
	}

	// 多个参数
	public static void mulParameter() {
		String hql = "from  Card as c where c.cardType.cardTypeId in (3,2)";
		Query query = son.createQuery(hql);
		// query.setParameterList("id", new Object[]{1,2});
		List<Card> cards = query.list();
		for (Card o : cards) {
			System.out.println(o.getCardName());
		}
	}

	// inner join 查询结果为多个对象的集合
	public static void innerJoin() {
		String hql = "from  Card as c inner join c.cardType";
		Query query = son.createQuery(hql);
		List<Object[]> cards = query.list();
		for (Object[] o : cards) {
			System.out.println(((Card) o[0]).getCardName() + "\t"
					+ ((CardType) o[1]).getCreateDate());
		}
	}

	// leftJoin 查询结果为多个对象的集合
	public static void leftJoin() {
		String hql = "from  CardType as c left join c.cards";
		Query query = son.createQuery(hql);
		List<Object[]> cards = query.list();
		for (Object[] o : cards) {
			// 由于保存卡片时在多的一方card进行操作，使用了级联。但手动插入的cardType可能没有相应的卡片
			if (o[1] != null) {// 当卡片不为空时
				System.out.println(((CardType) o[0]).getCardTypeName() + "\t"
						+ ((Card) o[1]).getCardName());
			} else {
				System.out.println(((CardType) o[0]).getCardTypeName()
						+ "\t没有相应的卡片");
			}
		}
	}

	// rightJoin 查询结果为多个对象的集合
	public static void rightJoin() {
		String hql = "from  CardType as c right join c.cards";
		Query query = son.createQuery(hql);
		List<Object[]> cards = query.list();
		// 插入时保证了每张卡片的类型，所以此处不用判断卡片类型是否为空
		for (Object[] o : cards) {
			System.out.println(((CardType) o[0]).getCardTypeName() + "\t"
					+ ((Card) o[1]).getCardName());
		}
	}

	// 使用子查询
	public static void childSelect() {
		String hql = "from  CardType as c where (select count(*) from c.cards)>0";
		Query query = son.createQuery(hql);
		List<CardType> cards = query.list();
		for (CardType c : cards) {
			System.out.println(c.getCardTypeName() + "\t" + c.getCreateDate());
		}
	}

	// 程序入口
	public static void main(String[] args) {
		// 测试方法
		Transaction tr = son.beginTransaction();

		// update();
		mulParameter();
		tr.commit();
		son.close();
		fac.close();
	}
}

hibernate投影查询：

String hql="select u.id,u.name from user as u"  //1方法

String hql="select new com.mypack.User2(u.id,u.name) from User as u "  //2方法

Iterator userHQL= session.createQuery(hql).iterate();

 

while (userHql.hasNext()) {
   User user=(User)userHql.next();
   

   Object[] row=(Object[]) userHql.next();
   int id=(Integer)row[0];
   String nameString =(String)row[1];
   System.out.print(id+"\t"+nameString);
   
   //User2 user2=(User2) userHql.next();
   //System.out.println(user2.getId()+"\t\t"+user2.getName());
  } 

--------------------------------------------------

package com.mypack;

public class User2 {
 private int id;
 private String name;
 public User2(int id,String nameString){
  this.id=id;
  this.name=nameString;
 }

    ......省略了属性的get,set方法

}


yaerfeng
关注
专栏目录
Hibernate中HQL语句
zhangfengBX的博客
10-15 494
HQL: Hibernate Query Language, 一个纯面向对象的查询语言. 其语法中对语法关键字大小写不敏感, 这种特性与SQL语言类似.其整体结构也与SQL语言类似. 基本规则 1. HQL语法类似于SQL，也是一种select from结构的语句。但是他后面跟的不是表名和字段名，而是类名和属性名。 2. HQL基本查询语法跟SQL很类似 3. HQL大小写不敏感。但是
Hibernate之HQL
阳某的博客
07-18 716
文章目录什么是HQLHQL通用分页查询 什么是HQL HQL是Hibernate Query Language的缩写，也就是Hibernate框架的查询语句，既然都是查询数据库的数据，那么它和SQL有什么区别？ HQL与SQL的区别: ①HQL是面向对象的查询语言，它的from语句后面接的是类名/属性，SQL是面向结构查询语言，from后面是接表名/列名 ②HQL区分大小写,关键字不区分大小写，比...
hibernate中HQL语句
小小黑
05-17 455
package test; import entity.Commodity; import entity.Customer; import entity.Seller; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.Transaction; import util.HibernateU
hibernate中HQL查询语句
饮冰室人的博客
11-19 7819
参考https://www.oschina.net/code/snippet_1051545_36896 我的查询示例 参考我的项目示例： // 根据HQl语句查询 @Override public List<User> findByHQL(String hql) { List<User> list = new ArrayList<>();
JSP 开发之hibernate的hql查询多对多查询
10-19
在HQL中查询多对多关系，我们需要使用JOIN语句来联接这两个实体。假设我们想查询所有属于特定分组ID集合的试题，我们可以构建如下的HQL查询： ```java String[] groupIds = ojbects[1].toString().split(","); ...
Hibernate中使用HQLQuery查询全部数据和部分数据的方法实例
08-26
Hibernate中使用HQLQuery查询全部数据和部分数据的方法实例 在 Hibernate 框架中，HQL（Hibernate Query Language）是一种强大的查询语言，允许开发者使用 SQL 风格的语句来查询和操作数据。HQL 提供了多种查询方式...
Hibernate-HQL.rar_HQL_hibernate hql
09-23
2. 避免在HQL中使用SQL函数：尽量用Hibernate提供的函数，以确保跨数据库兼容性。 3. 优化查询性能：合理设计数据库索引，避免全表扫描，尽量减少JOIN操作。 总之，Hibernate-HQL是Java开发中处理数据库查询的重要...
hibernate hql语句
jiang25810的博客
12-03 484
1.什么是hql HQL是Hibernate Query Language的缩写，提供更加丰富灵活、更为强大的查询能力；HQL更接近SQL语句查询语法。 hql和sql区别/异同 HQL SQL 操作的是类名/属性 操作的是表名/列名 语句区分大小写,关键字不区分大小写 语句不区分大小写 ?，从下标0开始计算位置(hibernate5之后不支持) ?，从顺序1开始计算位置 :命名参数 ...
hibernate hql 语句
yishuihanxun的博客
06-05 344
1、单属性查询  用 List&lt;String&gt;来接受2、多属性查询              a 可以用 List&lt;Object[]&gt;来接受                b 可以直接在 hql语句中 编写 如SELECT new Tb_item (xxx,xxx) FROM Tb_item tb ...... 这样做的前提是 Tb_item  必须有 Tb_item (x...
hibernate HQL语句
ahong_1920的博客
12-03 804
HQL语句的几种处理情况 建立持久化类 public class Book { private Integer book_id; private String book_name; private Set&lt;Category&gt; categories = new HashSet&lt;&gt;(); public Book() { } public Intege...
hibernate的hql查询语句总结
LeefengBoy的博客
10-02 6384
在这里通过定义了三个类，Special、Classroom、Student来做测试，Special与Classroom是一对多，Classroom与Student是一对多的关系，这里仅仅贴出这三个bean的属性代码： Special类： public class Special { private int id; private String name; pri
hibernate框架中使用hql语句查询数据库
QuedYin的博客
05-13 2646
hibernate框架中使用hql语句查询数据库1.基本查询首先写hql语句，String hql = “from User”，User是你要查询的对象类名，当类名不唯一时需要写出完整类名，比如在一个项目中两个包中都含有User类时，hql语句应该这样写, Stirng hql = "from com.ss.model.User"; 根据hql语句创建查询对象。 session.createQue...
Hibernate中使用Session操作数据以及部分简单HQL（hibernate query language）
HLoach的博客
03-09 1812
1.Session中的方法： save：新增数据 get：获取一条数据 load：获取一条数据 update：更新数据 delete：删除数据 注：get方法和load方法区别：get是先从一级缓存中获取数据，再从耳机缓冲中获取数据，而load
HQL基础汇总
stopping5的博客
04-26 3491
一、HQL简介 HQL全称是Hibernate Query Language。是一种面向对象（核心）的查询语言。SQL的操作对象是数据列、表等数据库数据，而HQL操作的是类、实例、属性。 二、HQL使用 1、实体查询form子句 如果from前面没有指定select内容，就是将整个User对象取出，封装到结果Query中。如果是得到单个结果，通过query.uniqueResu...
HQL查询
最新发布
weixin_45012397的博客
05-20 2015
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IYB7fiwW-1684578013741)(img/17_hangzhuanlie.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TkriOIZI-1684578013741)(img/08_join03.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CY5yxTU7-1684578013741)(img/09_join04.png)]
什么是HQL
Wxh_bai的博客
04-06 2440
Hadoop管理员：管理Hadoop集群的部署、维护和安全性，包括用户管理、数据源管理和HQL查询优化等，以保证Hadoop集群的正常运行和数据的安全性。数据分析师：使用HQL进行数据分析和可视化，包括数据的导入、清洗、转换、建模和报表设计等，以实现数据的探索和发现。优化查询语句：优化查询语句可以减少查询的响应时间，包括使用合适的查询条件、减少不必要的表连接和使用索引等。调整查询计划：调整查询计划可以优化查询性能，包括使用合适的分区、调整数据分布和使用合适的并行度等。
Hibernate的HQL查询语言详解
Hibernate Query Language (HQL) 是Hibernate框架中一种面向对象的查询语言，它允许开发者用面向对象的方式来查询数据库，而不是直接使用SQL。HQL的设计理念是使得数据库操作更加符合面向对象编程的思维，减轻了在...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值