`

栏目、帖子、回复(设置导航ManyToOne便于操作 QBC/QBE语句)02

HQL 
阅读更多
栏目、帖子、回复(设置导航ManyToOne便于操作QBC/QBE语句)02



Criteria查询也称QBC查询:全称为Query By Criteria;它是一种采用面向
对象的方式,封装查询条件,进行查询。

CriteriaRestriction常用的限定查询方法方法说明
Restrictions.Eq()对应SQL中的“= ”
Restrictions。alleq()对应Map,使用key/value进行多个相等的值的对比
Restrictions。gt()对应SQL的大于“> ”;
Restrictions。ge()对应SQL的大于等于“>= ”
Restrictions。lt()对应SQL的小于“<”
Restrictions。le()对应SQL的小于等于“=<”Restrictions。le()对应SQL的小于等于“=<”
Restrictions。between()对应SQL的between ;
Restrictions。like()对应SQL中的like语句可以使用MatchMode  设定like 语句的匹配模式
Restrictions。in()对应SQL中的in ;
Restrictions。and()对应SQL中的and
Restrictions。or()对应SQL中的or
Restrictions。not()对应SQL中的not





一、Category.java

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Category {
	private int id;
	private String name;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}



二、Top.java

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;

@Entity
@NamedQueries(
		{
			@NamedQuery(name="topic.selectCertainTopic", query="from Topic t where t.id = :id")
		}
		)
		/*
@NamedNativeQueries(
		{
			@NamedNativeQuery(name="topic.select2_5Topic", query="select * from topic limit 2, 5")
		}
		)
		*/

public class Topic {
	private int id;
	private String title;
	private Category category;
	private Date createDate;
	private List<Msg> msgs = new ArrayList<Msg>();
	@OneToMany(mappedBy="topic")
	public List<Msg> getMsgs() {
		
		return msgs;
	}
	public void setMsgs(List<Msg> msgs) {
		this.msgs = msgs;
	}
	public Date getCreateDate() {
		return createDate;
	}
	public void setCreateDate(Date createDate) {
		this.createDate = createDate;
	}
	@ManyToOne(fetch=FetchType.LAZY)
	public Category getCategory() {
		return category;
	}
	public void setCategory(Category category) {
		this.category = category;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	
}


三、Msg.java


import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Msg {
	private int id;
	private String cont;
	private Topic topic;
	@ManyToOne
	public Topic getTopic() {
		return topic;
	}
	public void setTopic(Topic topic) {
		this.topic = topic;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	
	public String getCont() {
		return cont;
	}
	public void setCont(String cont) {
		this.cont = cont;
	}
	
}



四、test.java


import java.util.Date;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class HibernateQLTest {
	private static SessionFactory sf;
	
	@BeforeClass
	public static void beforeClass() {
		sf = new AnnotationConfiguration().configure().buildSessionFactory();
	}
	@AfterClass
	public static void afterClass() {
		sf.close();
	}
	
	@Test
	public void testSchemaExport() {
		new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);
	}
	
	@Test
	public void testSave() {
		Session session = sf.openSession();
		session.beginTransaction();
		
		for(int i=0; i<10; i++) {
			Category c = new Category();
			c.setName("c" + i);
			session.save(c);
		}
		
		for(int i=0; i<10; i++) {
			Category c = new Category();
			c.setId(1);
			Topic t = new Topic();
			t.setCategory(c);
			t.setTitle("t" + i);
			t.setCreateDate(new Date());
			session.save(t);
			
		}
		
		for(int i=0; i<10; i++) {
			
			Topic t = new Topic();
			t.setId(1);
			Msg m = new Msg();
			m.setCont("m" + i);
			m.setTopic(t);
			session.save(m);
			
		}
		
		
		
		
		session.getTransaction().commit();
		session.close();
	}
	
	//is empty and is not empty
	@Test
	public void testHQL_20() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("from Topic t where t.msgs is empty");
		
		for(Object o : q.list()) {
			Topic t = (Topic)o;
			System.out.println(t.getId() + "-" + t.getTitle());
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_21() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("from Topic t where t.title like '%5'");
		
		for(Object o : q.list()) {
			Topic t = (Topic)o;
			System.out.println(t.getId() + "-" + t.getTitle());
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_22() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("from Topic t where t.title like '_5'");
		
		for(Object o : q.list()) {
			Topic t = (Topic)o;
			System.out.println(t.getId() + "-" + t.getTitle());
		}
		session.getTransaction().commit();
		session.close();
		
	}
	//不重要
	@Test
	public void testHQL_23() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("select lower(t.title)," +
											 "upper(t.title)," +
											 "trim(t.title)," +
											 "concat(t.title, '***')," +
											 "length(t.title)" +
											 " from Topic t ");
		
		for(Object o : q.list()) {
			Object[] arr = (Object[])o;
			System.out.println(arr[0] + "-" + arr[1] + "-" + arr[2] + "-" + arr[3] + "-" + arr[4] + "-");
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_24() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("select abs(t.id)," +
											 "sqrt(t.id)," +
											 "mod(t.id, 2)" +
											 " from Topic t ");
		
		for(Object o : q.list()) {
			Object[] arr = (Object[])o;
			System.out.println(arr[0] + "-" + arr[1] + "-" + arr[2] );
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_25() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("select current_date, current_time, current_timestamp, t.id from Topic t");
		
		for(Object o : q.list()) {
			Object[] arr = (Object[])o;
			System.out.println(arr[0] + " | " + arr[1] + " | " + arr[2] + " | " + arr[3]);
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_26() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("from Topic t where t.createDate < :date");
		q.setParameter("date", new Date());
		for(Object o : q.list()) {
			Topic t = (Topic)o;
			System.out.println(t.getTitle());
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_27() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("select t.title, count(*) from Topic t group by t.title") ;
		for(Object o : q.list()) {
			Object[] arr = (Object[])o;
			System.out.println(arr[0] + "|" + arr[1]);
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_28() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("select t.title, count(*) from Topic t group by t.title having count(*) >= 1") ;
		for(Object o : q.list()) {
			Object[] arr = (Object[])o;
			System.out.println(arr[0] + "|" + arr[1]);
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_29() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("from Topic t where t.id < (select avg(t.id) from Topic t)") ;
		for(Object o : q.list()) {
			Topic t = (Topic)o;
			System.out.println(t.getTitle());
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_30() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("from Topic t where t.id < ALL (select t.id from Topic t where mod(t.id, 2)= 0) ") ;
		for(Object o : q.list()) {
			Topic t = (Topic)o;
			System.out.println(t.getTitle());
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	//用in 可以实现exists的功能
	//但是exists执行效率高
	@Test
	public void testHQL_31() {
		Session session = sf.openSession();
		session.beginTransaction();// t.id not in (1)
		Query q = session.createQuery("from Topic t where not exists (select m.id from Msg m where m.topic.id=t.id)") ;
//		Query q = session.createQuery("from Topic t where exists (select m.id from Msg m where m.topic.id=t.id)") ;
		for(Object o : q.list()) {
			Topic t = (Topic)o;
			System.out.println(t.getTitle());
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	//update and delete
	//规范并没有说明是不是要更新persistent object,所以如果要使用,建议在单独的trasaction中执行
	
	@Test
	public void testHQL_32() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.createQuery("update Topic t set t.title = upper(t.title)") ;
		
		q.executeUpdate();
		q = session.createQuery("from Topic");
		for(Object o : q.list()) {
			Topic t = (Topic)o;
			System.out.println(t.getTitle());
		}
		session.createQuery("update Topic t set t.title = lower(t.title)")
			.executeUpdate();
		session.getTransaction().commit();
		session.close();
		
	}
	
	//不重要
	@Test
	public void testHQL_33() {
		Session session = sf.openSession();
		session.beginTransaction();
		Query q = session.getNamedQuery("topic.selectCertainTopic");
		q.setParameter("id", 5);
		Topic t = (Topic)q.uniqueResult();
		System.out.println(t.getTitle());
		session.getTransaction().commit();
		session.close();
		
	}
	
	//Native(了解)
	@Test
	public void testHQL_34() {
		Session session = sf.openSession();
		session.beginTransaction();
		SQLQuery q = session.createSQLQuery("select * from category limit 2,4").addEntity(Category.class);
		List<Category> categories = (List<Category>)q.list();
		for(Category c : categories) {
			System.out.println(c.getName());
		}
		session.getTransaction().commit();
		session.close();
		
	}
	
	@Test
	public void testHQL_35() {
		//尚未实现JPA命名的NativeSQL
		
	}
	
	public static void main(String[] args) {
		beforeClass();
	}
}
分享到:
评论

相关推荐

    hibernate manytoone

    总的来说,`ManyToOne`是Hibernate中用于处理一对多关系的重要工具,它通过注解或者XML配置实现对象关系映射,提供了便捷的导航属性和级联操作,同时也支持懒加载以优化性能。理解并熟练运用`ManyToOne`关系,对于...

    SpringBoot-SpringData-ManyToOne

    标题“SpringBoot-SpringData-ManyToOne”涉及到的是Spring Boot与Spring Data JPA在处理多对一关系时的应用。Spring Boot是Spring框架的一个轻量级版本,它简化了配置和项目初始化,使得开发者能够更快地开始开发...

    Hibernate生产SQL语句

    在Java开发中,Hibernate是一个非常重要的对象关系映射(ORM)框架,它允许开发者通过面向对象的方式操作数据库,而无需直接编写SQL语句。本文将深入探讨如何模仿Hibernate生成SQL语句,以及如何利用Java反射技术来...

    博客(GreenDao一对多关系操作)的示例demo

    它允许开发者通过简单的Java接口操作数据库,避免了繁琐的SQL语句编写。GreenDao支持实体类的创建、增删改查以及复杂的数据库操作,包括一对多、多对一和多对多的关系映射。 ### 2. 一对多关系 在数据库设计中,一...

    hibernate的表关联操作-hibernate02

    进行表关联操作时,Hibernate允许我们在实体类层面定义这些关系,然后在程序中直接操作对象,而不是SQL语句。这样不仅可以提高开发效率,还使得代码更加面向对象。例如,要添加一个新的订单,我们只需要创建一个`...

    JPA中的一对多双向关联与级联操作

    例如,当我们在`User`上执行`entityManager.remove(user)`时,由于设置了`CascadeType.ALL`,JPA会自动删除所有与该用户相关的`Post`。 但是,级联操作需谨慎使用,因为它们可能导致数据丢失或不一致。例如,如果...

    hibernate 关联映射(一) many to one

    在Java世界中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者用面向对象的方式处理数据库操作。在Hibernate中,关联映射是连接数据库表之间关系的关键概念,使得对象模型能够准确反映数据库结构...

    Hibernate执行持久层访问步骤

    它允许开发者使用面向对象的方式进行数据操作,而无需关注底层的SQL语句。本文将深入探讨Hibernate执行持久层访问的详细步骤,帮助开发者更好地理解和应用Hibernate。 一、配置环境 1. 添加Hibernate依赖:在项目中...

    09_JPA详解_使用JPQL语句进行查询.zip

    JPA通过提供ORM(对象关系映射)功能,允许开发者使用面向对象的方式处理数据库操作,而无需过多关注SQL语句的编写。 **JPQL(Java Persistence Query Language)**是JPA的一部分,它是面向对象的查询语言,类似于...

    hibernate02.rarhibernate02.rarhibernate02.rarhibernate02.rarhibernate02.rarhibernate02.rarhibernate02.rarhibernate02.rarhibernate02.rarhibernate02.rarv

    标题中的“hibernate02.rar”重复多次,暗示了这个压缩包可能包含了与Hibernate相关的学习资料或项目实例,Hibernate是一个流行的Java持久层框架,用于简化数据库操作。描述中的内容同样重复,没有提供额外信息,...

    JPA加载_更新_删除对象及使用JPQL语句进行查询

    使用`@ManyToOne`或`@OneToOne`注解时,可以通过设置`fetch`属性来指定加载策略。 接下来是对象的更新。当你修改一个已加载的实体并调用`EntityManager`的`merge()`方法时,JPA会将对象的状态同步到数据库。如果...

    hibernate annotation

    2. **@Cascade** - 设置级联操作,如 save-update、delete 等。 **五、其他高级特性** 1. **@Inheritance** - 支持继承关系的映射,如 TABLE_PER_CLASS、SINGLE_TABLE、JOINED。 2. **@SecondaryTable** - 支持...

    Hibernate 配置以及简单的CRUD操作

    通过这些操作,我们可以轻松地在Java应用中处理数据库数据,而无需直接编写SQL语句,极大地提高了开发效率和代码的可维护性。在实际项目中,还需要注意事务管理、性能优化等方面,使得Hibernate能够更好地服务于我们...

    Mapping规则

    // 设置级联操作为 None,即不执行任何级联操作。 m.Unique(true); // 设置该属性为唯一。 }); ``` - **Column("OwnerID")**:此方法用于指定映射到数据库表中的列名。在这个例子中,`OwnerID`字段将映射到数据库...

    精通 hibernate (孙卫琴) pdf 版

    6. **@ManyToOne/@OneToOne/@OneToMany/@ManyToMany**:表示不同类型的关联关系。 #### 六、Hibernate的最佳实践 1. **延迟加载**:为了提高性能,Hibernate提供了延迟加载机制,可以在真正需要的时候再加载关联...

    hibernate_anoatation(中文版)

    它允许开发者用面向对象的方式来处理数据库记录,从而避免了大量的SQL语句编写工作。随着Hibernate的不断更新和完善,注解(Annotation)逐渐成为配置实体类与数据库表映射的主要方式之一。本文将详细介绍Hibernate...

    用hibernate操作多表的例子

    这可以通过在@OneToMany或@ManyToOne注解中设置cascade属性来实现,如 cascade=CascadeType.ALL(包含所有操作)。 六、缓存机制 Hibernate支持二级缓存,提高数据读取效率。一级缓存是Session级别的,每个Session...

Global site tag (gtag.js) - Google Analytics