`
Aubergine_kang
  • 浏览: 266787 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

学习脚步—HQL查询语句(自己学习使用)

CC++C#Hibernate编程 
阅读更多

package com.bjsxt.hibernate;

import java.util.Date;

import java.util.List;

import org.hibernate.Query;

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();

       }

       @Test

       public void testHQL_01() {

              Session session = sf.openSession();

              session.beginTransaction();

Query q = session.createQuery("from Category"); //EJBQL语句，也可称作HQL，因为前者是后者的一个子集。面向对象的查询语言，所以Category是类名。

              List<Category> categories = (List<Category>)q.list();//将结果查询出来并组装成对象放到list集合中，要做一个类型转换。

              for(Category c : categories) {

                     System.out.println(c.getName());

              }

              session.getTransaction().commit();

              session.close();

       }

       @Test

       public void testHQL_02() {

              Session session = sf.openSession();

              session.beginTransaction();

              Query q = session.createQuery("from Category c where c.name > 'c5'");

              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_03() {

              Session session = sf.openSession();

              session.beginTransaction();

              Query q = session.createQuery("from Category c order by c.name desc");//倒叙排列

              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_04() {

              Session session = sf.openSession();

              session.beginTransaction();

              Query q = session.createQuery("select distinct c from Category c order by c.name desc");//倒叙排列，distinct c是指对象不会重复，就是主键不会重复，这里写不写无所谓。

              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_05() {

              Session session = sf.openSession();

              session.beginTransaction();

              /*Query q = session.createQuery("from Category c where c.id > :min and c.id < :max");//:是占位符，min是占位符的名称

              //q.setParameter("min", 2); 自动转换格式

              //q.setParameter("max", 8);

              q.setInteger("min", 2); 自己指定类型，这句代码的返回值是querry本身，所以就有了下面的链式编程

              q.setInteger("max", 8);*/

             

              Query q = session.createQuery("from Category c where c.id > :min and c.id < :max")

                     .setInteger("min", 2)

.setInteger("max", 8);     //链式编程

              List<Category> categories = (List<Category>)q.list();

              for(Category c : categories) {

                     System.out.println(c.getId() + "-" + c.getName());

              }

              session.getTransaction().commit();

              session.close();

       }

       @Test 

       public void testHQL_06() {

              Session session = sf.openSession();

              session.beginTransaction();

              Query q = session.createQuery("from Category c where c.id > ? and c.id < ?");

              q.setParameter(0, 2)

.setParameter(1, 8);     //简单解释了链式编程

//            q.setParameter(1, 8);

              List<Category> categories = (List<Category>)q.list();

              for(Category c : categories) {

                     System.out.println(c.getId() + "-" + c.getName());

              }

              session.getTransaction().commit();

              session.close();

       }

       //分页

       @Test

       public void testHQL_07() {

              Session session = sf.openSession();

              session.beginTransaction();

       //oracle中需要三层嵌套，mysql中需要使用limit

              Query q = session.createQuery("from Category c order by c.name desc");

              q.setMaxResults(4);        //设定最大的结果集是4，即每页是4条

              q.setFirstResult(2);         //从第2条开始取       运行结果:倒叙排列结果是9 8 7 ……1

                                //那么按照约束则最终显示的是：8 7 6 5

              List<Category> categories = (List<Category>)q.list();

              for(Category c : categories) {

                     System.out.println(c.getId() + "-" + c.getName());

              }

              session.getTransaction().commit();

              session.close();

       }

       @Test

       public void testHQL_08() {

              Session session = sf.openSession();

              session.beginTransaction();

              Query q = session.createQuery("select c.id,  c.name from Category c order by c.name desc");

       //以前都是取的是对象，现在是两个字段，返回是一个list，list里面装了Object类型的数组，

       1   c0    一条记录是一个数组，左边是数组展开里面的内容

       2   c1    多个数组组合到一起可以看做是一个list                   

              List<Object[]> categories = (List<Object[]>)q.list();

              for(Object[] o : categories) {

                     System.out.println(o[0] + "-" + o[1]);

              }

              session.getTransaction().commit();

              session.close();

       }

       //设定fetch type 为lazy后将不会有第二条sql语句

       @Test

       public void testHQL_09() {

              Session session = sf.openSession();

              session.beginTransaction();

              Query q = session.createQuery("from Topic t where t.category.id = 1"); //两张表联合查询

       //many-to-one的映射（fetchType类型默认是EAGER）最后结果是输出category的id为1的//topic的titile属性

              List<Topic> topics = (List<Topic>)q.list();

              for(Topic t : topics) {

                     System.out.println(t.getTitle());

                     System.out.println(t.getCategory().getName());    //1+N问题

              }

              session.getTransaction().commit();

              session.close();

       }

       //设定fetch type 为lazy后将不会有第二条sql语句

       @Test

       public void testHQL_10() {

              Session session = sf.openSession();

              session.beginTransaction();

              Query q = session.createQuery("from Topic t where t.category.id = 1");

              List<Topic> topics = (List<Topic>)q.list();

              for(Topic t : topics) {

                     System.out.println(t.getTitle());

              }

              session.getTransaction().commit();

              session.close();

       }

       @Test

       public void testHQL_11() {

              Session session = sf.openSession();

              session.beginTransaction();

              Query q = session.createQuery("from Msg m where m.topic.category.id = 1");//导航再导航

//其实相当于是取了板块为1的里面的所有的帖子

//many-to-one设置的是导航，不设置导航QL语句就会麻烦，需要表连接，可以如此写//m.topic.category.id就是因为设置了导航

分享到：
| 学习脚步----hibernate编程中的映射关系简 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    HQL语句 HQL语句

    HQL语句 HQL语句 HQL语句 HQL语句 HQL语句

    Hibernate HQL查询语句总结.docx

    * 使用 HQL 语句可以查询出实体对象所对应的所有数据，并将数据封装成实体对象。 * HQL 语句可以使用 where 字句，并可以在 where 字句中使用各种表达式、比较操作符、 Logical 操作符等。 * HQL 语句可以用于查询...

    HQL语句大全HQL语句大全

    - 使用Session的`createQuery`方法来创建Query对象，并将HQL语句作为参数传入。 ```java Query query = session.createQuery(hql); ``` 4. **设置参数值** - 如果HQL语句中有参数，则需要为这些参数设置值。 ...

    超级详细的hql查询语句教程

    ### HQL查询语句详解 #### 一、HQL简介 Hibernate Query Language（HQL）是一种面向对象的查询语言，其语法与SQL相似但并非完全相同。HQL的设计旨在更好地支持面向对象编程特性，比如继承、多态以及关联等概念。...

    全面解析HQL语句 非常详细直接的HQL语句的功能介绍

    `from`子句是HQL语句的基础，用于指定查询的数据源。例如，`from Person as p`表示查询的目标是从`Person`实体类中选择所有实例。此子句支持简单的全表扫描，也能够进行更复杂的多表联接查询。 ### 2. select子句 ...

    hql基础语句

    HQL（Hibernate Query Language）是Hibernate框架中用于...以上内容涵盖了HQL的基础用法，包括ID生成策略、基本查询语句、集合参数传递和不同的传参方式。通过这些知识点，你可以更有效地使用Hibernate进行数据库操作。

    HQL查询及语法

    2. **编写HQL语句**：根据需求构建HQL查询语句，这一步骤需要熟悉HQL语法结构。 3. **创建Query对象**：利用Session对象的`createQuery`方法，传入HQL语句创建Query实例。 4. **设置参数**：如果HQL语句中包含...

    学习HQL语句

    HQL查询语言基础知识 HQL（Hibernate Query Language）是一种面向对象的查询语言，建立在面向对象的基础上。它提供了类SQL查询的功能，但查询目标是对象，而不是记录。HQL 拥有面向对象语言的所有特性，包括多态、...

    HQL语句查询

    HQL语句查询

    hibernate 中HQL语句查询学习笔记

    ### Hibernate中HQL语句查询学习笔记 #### HQL基础 **HQL**（Hibernate Query Language）是Hibernate框架推荐使用的查询语言，它提供了一种面向对象的方式来查询数据库，支持多种复杂的查询操作，如继承、多态及...

    hql语句 使用大全

    ### HQL语句使用大全 HQL（Hibernate Query Language）是一种面向对象的查询语言，它提供了灵活而强大的数据检索方式，使开发人员能够更高效地与数据库交互。本文将详细介绍HQL的基本用法及高级特性。 #### 1. ...

    最新HQL语句实例代码

    常见HQL语句的示例包括输出结果，以及语句的分析总结

    hql查询语句

    本文将详细探讨HQL中的查询语句，特别是涉及的统计函数和一些关键子句。 首先，`from`子句用于指定查询的源，如`from Person`表示从`Person`持久化类中选取所有实例。为了提高可读性，通常会使用别名，如`from ...

    hql语句大全hql语句大全

    ### HQL语句详解：精通Hibernate查询语言 #### 引言 HQL（Hibernate Query Language）是Hibernate框架中用于执行数据库操作的一种强大的查询语言。它提供了面向对象的语法，允许开发人员以一种接近于编程语言的方式...

    hql语句语法详解hql语句

    命名查询是一种将HQL查询语句保存为名称/查询映射的方式。这种方式可以使代码更加清晰，并且便于维护。命名查询通常在配置文件或注解中定义。例如，在配置文件中定义一个名为 `findPersons` 的命名查询： ```xml ...

    hibernate-HQL语句大全

    hibernate-HQL语句大全

    hql精点查询语句.doc

    标题和描述均提到了“HQL精点查询语句”，这明确指向了HQL（Hibernate Query Language）在数据库查询中的应用。HQL是Hibernate框架提供的一种面向对象的查询语言，它允许开发人员以面向对象的方式编写数据库查询，而...

    HQL语法入门学习HQL语法入门学习

    这两个方法都遵循了上述的HQL使用步骤，通过`createQuery`创建Query对象，然后设置参数并执行查询。在`findPersonByHappenDate`中，还涉及到日期的解析和设置，这是在处理时间相关的查询时常见的做法。 总结来说，...

    HQL语句详解Select/update/deletefromwhere...

    需要注意的是，在Hibernate中查询时，如果实体之间存在继承关系（如`Employee`类继承自`HourlyEmployee`和`SalariedEmployee`），则可以通过类似`"from Employee"`这样的HQL语句来查询基类`Employee`的所有子类实例...

    HQL语句的语法

    HQL（Hibernate Query Language）是Hibernate框架中用于操作对象关系映射（ORM）的SQL-like语言，它允许开发者以面向对象的方式来查询数据库。HQL语句的语法结构与SQL相似，但更注重对象和类的概念。以下将详细介绍...

Magicbox
Global site tag (gtag.js) - Google Analytics