`
penghao122
  • 浏览: 363171 次
  • 性别: Icon_minigender_1
  • 来自: 广东珠海
社区版块
存档分类
最新评论

hibernate 全面学习【hibernate hsql语句学习 】

HibernatejunitSQLCC++ 
阅读更多
Hibernate hql

* 注意hql的大小写敏感性

1、实体对象的查询，查询的是实体对象的数据【重要】
  * n+1问题，在默认配置的情况下，使用query.iterate()操作，有可能有n＋1问题，所谓
  n+1，指在查询对象数据的时候，发出了n＋1条查询语句。
  1：首先发出了一条查询语句，查询对象的id列表
  n:在迭代访问每个对象的时候，如果缓存中没有对象数据，Hibernate会在此发出一条查询语句，
     查询相应的对象
 
  *List操作与Iterate操作的区别
   list,每次都会发出一条查询语句，查询所有的对象
   iterate,首先发出一条查询语句，查询对象的id列表，然后根据缓存情况，决定
    是否发出更多的查询语句，来查询对象数据
   参见：SimpleObjectQueryTest2.java
  
2、简单属性查询
  * 单个属性查询，返回的结果集属性的列表，其元素和属性的类型一致
  * 多个属性查询,返回的结果集是数组类型，数组的长度和查询的属性数量相关，数组中元素的类型与相应的属性类型相同
  参见：SimplePropertyQueryTest.java
 
3、条件查询【重要】                 
  * 可以拼字符串的形式传递参数
  * 可以用过？来传递参数（注意索引值是从0开始的，跟jdbc不同，jdbc是从1开始的）
  * 可以通过 ：参数名 来传递参数（即命名参数方式）
  * 如果对应的参数值是多个，可以调用setParamterList()方法开传递
  * 在HQL中可以使用数据库的函数，如date_format()
  参见：SimpleConditionQueryTest.java

4、hibernate也支持直接使用原生sql进行查询
  参见：SqlQueryTest.java
 
5、外置的命名查询
  * 在映射文件中通过<query>标签定义hql
  * 在程序中使用session.getNameQuery()方法获得这个查询
  参见：Student.hbm.xml,NameQueryTest.java
 
6、查询过滤器
  * 定义过滤器参数
  * 在类映射文件中使用这些参数
  * 在session中启用过滤器
  参见：Student.hbm.xml,FilterQueryTest.java
 
7、对象导航查询，在HQL语句中，可以使用.的方式进行对象导航【重要】
   参见：ObjectNavQueryTest.java

8、连接查询（在对象里可以直接导航）【重要】
  * 内连接
  * 外连接(左连接/右连接)  
   参见：JionQueryTest
  
9、统计查询
  参见：StatQueryTest.java
 
10、分页查询【重要】
  * 通过query接口中的setFirstResult()和setMaxResults() 进行分页
  参见：PageQueryTest
 
11、DML风格的操作（尽量） 
  


package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

public class JionQueryTest extends TestCase {
	
	/**
	 * 内连接，从Student连接到Classes
	 *
	 */
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			List students = session.createQuery("select c.name, s.name from Student s join s.classes c ")
			.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	/**
	 * 左外连接
	 *
	 */
	public void testQuery2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			List students = session.createQuery("select c.name, s.name from Classes c left join c.students s ")
			.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

	/**
	 * 右外连接
	 *
	 */	
	public void testQuery3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			List students = session.createQuery("select c.name, s.name from Classes c right join c.students s ")
			.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	/**
	 * 内连接，从Classes连接到Student
	 *
	 */
	private void testQuery4() {
		
	}
}


package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 外置的命名查询测试
 * @author Administrator
 *
 */
public class NameQueryTest extends TestCase {
	
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			List students =  session.getNamedQuery("searchStudents")
			                        .setParameter(0, 10)
			                        .list();

			for (Iterator iter = students.iterator();iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}	
}



package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 对象导航查询测试
 * @author Administrator
 *
 */
public class ObjectNavQueryTest extends TestCase {

	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			List students = session.createQuery("select s.name from Student s where s.classes.id < 2").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				String name = (String)iter.next();	
				System.out.println(name);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}	
}




package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 分页查询测试
 * @author Administrator
 *
 */
public class PageQueryTest extends TestCase {
	
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Query query = session.createQuery("from Student");
			query.setFirstResult(27);
			query.setMaxResults(5);
			List students = query.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getId() + ", " + student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
}



package com.bjsxt.hibernate;

import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import junit.framework.TestCase;

public class SimpleConditionQueryTest extends TestCase {

	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//条件查询，拼字符串
			List students = session.createQuery("SELECT s.id, s.name FROM Student s WHERE s.name LIKE '%1%'")
			.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}
	
	public void testQuery2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//条件查询，使用 ？ 的方式传递参数
			Query query = session.createQuery("SELECT s.id, s.name FROM Student s WHERE s.name LIKE ?");
			
			//传递参数
			//参数的索引是从0开始的
			//传递的字符串，无需用''单引号括起来
			query.setParameter(0, "%1%");
			
			List students = query.list(); 
			
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}

	public void testQuery3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//条件查询，使用 ：参数名称 的方式传递参数
			Query query = session.createQuery("SELECT s.id, s.name FROM Student s WHERE s.name LIKE :myname");
			
			//传递参数
			query.setParameter("myname", "%1%");
			
			List students = query.list(); 
			
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}
	
	public void testQuery4() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//条件查询,因为setParameter方法返回Query接口，所以可以用省略的方式来查询
			List students = session.createQuery("SELECT s.id, s.name FROM Student s WHERE s.name LIKE :myname and s.id = :myid")
			.setParameter("myname", "%1%")
			.setParameter("myid", 15)
			.list();
			
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}

	public void testQuery5() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//条件查询,支持in，需要用setParameterList()进行参数传递
			List students = session.createQuery("SELECT s.id, s.name FROM Student s WHERE s.id in(:myids)")
			.setParameterList("myids", new Object[]{1, 3, 5})
			.list();
			
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}

	public void testQuery6() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//条件查询,支持in，需要用setParameter进行参数传递
//			List students = session.createQuery("SELECT s.id, s.name FROM Student s WHERE " +
//					"date_format(s.createTime, '%Y-%m') =?")
//			.setParameter(0, "2007-01")
//			.list();

			List students = session.createQuery("SELECT s.id, s.name FROM Student s WHERE " +
			"substring(s.createTime, 1, 7) =?")
         	.setParameter(0, "2007-01")
	        .list();
			
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}

	public void testQuery7() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//条件查询,支持in，需要用setParameter进行参数传递

			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
			List students = session.createQuery("SELECT s.id, s.name FROM Student s WHERE " +
			"s.createTime between ? and ? ")
         	.setParameter(0, format.parseObject("2007-01-01"))
         	.setParameter(1, format.parseObject("2007-03-01"))
	        .list();
			
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}
	
}



package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 对象查询中的list操作和iterator操作的差异
 * @author Administrator
 *
 */
public class SimpleObjectQueryTest2 extends TestCase {
	
	public void testQueryWithListMethod() {
			Session session = null;
			try {
				session = HibernateUtils.getSession();
				
				/**
				 * 将发出一条查询语句，获取Student的集合数据
				 * select student0_.id as id1_, student0_.name as name1_, 
				 * student0_.createTime as createTime1_, student0_.classid as classid1_ 
				 * from t_student student0_
				 */
				List students = session.createQuery("from Student").list();
				for (Iterator iter = students.iterator();iter.hasNext();) {
					Student student = (Student)iter.next();
					System.out.println(student.getName());
				}
			}catch(Exception e) {
				e.printStackTrace();
			}finally {
				HibernateUtils.closeSession(session);
			}	
		}		
	
	public void testQueryWithIterateMethod() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//先发出查询id的列表语句
			//select student0_.id as col_0_0_ from t_student student0_
			//再依次发出查询对象的sql（根据id）
			//select student0_.id as id1_0_, student0_.name as name1_0_, 
			//student0_.createTime as createTime1_0_, student0_.classid as classid1_0_ 
			//from t_student student0_ where student0_.id=?
			Query query = session.createQuery("from Student");
			Iterator students = query.iterate();
			while (students.hasNext()) {
				Student student = (Student)students.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}	
	
	public void testQueryWithListAndIterate() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Query query = session.createQuery("from Student");
			List students = query.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			
			//如果使用iterate进行查询
			//因为list操作已经将对象加载到了session的一级缓存，所以
			//再使用iterate操作的时候，它先会发出查询id列表的查询语句
			//再根据id到缓存中获取相关的数据
			//只有再缓存中找不到相关数据的情况下，才会再次发出sql进行查询
			Iterator studentsIter = query.iterate();
			while (studentsIter.hasNext()) {
				Student student = (Student)studentsIter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
		
	}
	
	public void testQueryWithListAndList() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			Query query = session.createQuery("from Student");
			List students = query.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			
			//再次发出发出sql
			//在默认情况下，list每次都会向数据库发出查询对象数据的sql，
			//除非配置了查询缓存，所以下面的list()操作，虽然在session已经有了
			//对象缓存数据，但list()并不理会这个中缓存，而再次发出查询语句进行查询
			students = query.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	
}


package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 对象查询的基本测试
 * @author Administrator
 *
 */
public class SimpleObjectQueryTest extends TestCase {
	
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//可以忽略select语句
			List students = session.createQuery("from Student").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				
				//返回值是Student对象
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testQuery2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//可以忽略select语句,表可以加别名
			List students = session.createQuery("from Student s").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				
				//返回值是Student对象
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

	public void testQuery3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//可以忽略select语句,表可以加别名
			List students = session.createQuery("from Student as s").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				
				//返回值是Student对象
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

	public void testQuery4() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//使用select关键字时，必须定义别名
			List students = session.createQuery("select s from Student s").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				
				//返回值是Student对象
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

	public void testQuery5() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不支持select * ....这样的HQL查询语句
			List students = session.createQuery("select * from Student").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				
				//返回值是Student对象
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
}


package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 简单的属性查询
 * @author Administrator
 *
 */
public class SimplePropertyQueryTest extends TestCase {

	/**
	 * 单一属性查询
	 *
	 */
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			List students = session.createQuery("select name from Student").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				String name = (String)iter.next();
				System.out.println(name);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}			
	}
	
	/**
	 * 多个属性的查询
	 *
	 */
	public void testQuery2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//查询多个属性，其集合元素是对象数组
			//数组元素的类型，跟实体类的属性的类型相关
			List students = session.createQuery("select id, name from Student").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}			
	}

	public void testQuery3() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//查询多个属性，其集合元素是对象数组
			//数组元素的类型，跟实体类的属性的类型相关
			//更参见的用法，给对象起个别名，然后通过别名来引用属性值
			List students = session.createQuery("select s.id, s.name from Student s").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}			
	}
	
}



package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.SQLQuery;
import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 嵌入原生sql测试
 * @author Administrator
 *
 */
public class SqlQueryTest extends TestCase {
	
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			SQLQuery sqlQuery = session.createSQLQuery("select * from t_student");
			List students = sqlQuery.list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ", " + obj[1]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}
	
}



package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

public class StatQueryTest extends TestCase {
	
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			List students = session.createQuery("select count(*) from Student").list();
			Long count = (Long)students.get(0);
			System.out.println(count);
//			for (Iterator iter = students.iterator();iter.hasNext();) {
//				Long count = (Long)iter.next();	
//				System.out.println(count);
//			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}	
	
	public void testQuery2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			List students = session.createQuery("select c.id, c.name, count(s) from Student s join " +
					"s.classes c group by c.id, c.name").list();
			for (Iterator iter = students.iterator();iter.hasNext();) {
				Object[] obj = (Object[])iter.next();
				System.out.println(obj[0] + ",  " + obj[1] + ", " + obj[2]);
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}	
	
}


package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 查询过滤器测试
 * @author Administrator
 *
 */
public class FilterQueryTest extends TestCase {
	
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			session.enableFilter("idfilter")
			       .setParameter("myid", 10);
			
			List students = session.createQuery("from Student")
			.list();
			
			for (Iterator iter = students.iterator();iter.hasNext();) {
				
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}


package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import junit.framework.TestCase;

public class DMLQueryTest extends TestCase {
	
	public void testQuery1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			/**
			 * 使用这种风格的操作，将会造成内存中的对象与数据库中的数据不同步，所以
			 * 建议尽量少使用
			 */
			Query updateQuery =  session.createQuery("update Student a set a.name=? where a.id in(:ids)");
			updateQuery.setParameter(0, "张三");
			updateQuery.setParameterList("ids", new Object[]{1, 2});
			updateQuery.executeUpdate();
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}				
	}
}

 
 
                           
             
    
 
分享到：
| hibernate 全面学习【hibernate 粗粒度分析 ...
评论
1 楼 xinghaifeng2006 2010-04-06  
尚学堂的
发表评论

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

相关推荐

    Hibernate更新某些字段

    如果我们直接使用 Session.update(Object o) 方法，Hibernate 会生成一个更新所有字段的 SQL 语句。这可能会导致性能问题，特别是当某些字段类型是文本类型且内容非常大时。 例如，在下面的代码中，我们使用 ...

    JDBC-Datenbank-Hibernation-Buecherei:通过Hibernate框架使用Java访问HSQL数据库

    在这个项目中，开发者可以学习如何利用Hibernate简化Java对数据库的操作，而HSQL则提供了一个快速测试和开发环境。 【描述】"JDBC数据库Hibernate库" 提示我们关注的是Java中的JDBC API，它是Java程序连接和操作...

    hsql查询语法

    HSQL（Hibernate Query Language）是一种强大且灵活的查询语言，用于查询Hibernate应用程序中的数据。下面将对HSQL的基本语法和使用方法进行详细介绍。 1. 大小写敏感性问题 HSQL查询语句对大小写并不敏感，除了...

    hql语句语法详解hql语句

    ### HQL语句语法详解 HQL（Hibernate Query Language）是一种面向对象的查询语言，它提供了灵活而强大的机制来查询数据库中的数据，并将其映射到Java对象上。本篇文章将根据给定的信息深入探讨HQL的基本语法结构...

    hibernate连接各种数据库的方法

    通过本文的学习，我们了解了如何使用Hibernate配置不同类型的数据库连接。正确配置这些参数对于保证应用程序正常运行至关重要。此外，需要注意的是，在实际部署过程中还需要考虑诸如连接池设置等因素，以提高数据库...

    收集的全部HSQL DataBase资料(HSQL DataBase-关于Java 的纯数据库)

    这款数据库系统以其简洁的API、快速的性能和全面的SQL支持，在Java开发环境中得到了广泛应用。下面将详细介绍HSQL Database在Java中的使用及相关知识点。 一、HSQL Database的特点 1. **轻量级**: HSQL Database...

    hibernate3.1.2参考文档

    Hibernate 是一款强大的Java对象关系映射（ORM）框架，它简化了数据库与Java应用之间的交互，使得开发人员可以使用面向对象的方式来处理数据，而无需直接编写SQL语句。在Hibernate 3.1.2版本中，这个框架已经相当...

    Hibernate文档

    Hibernate是一个流行的Java对象关系映射（ORM）工具，它允许开发者使用面向对象的方式来处理数据库操作，减少了手动编写SQL语句的工作量。 1. Hibernate的基础知识 Hibernate的核心功能在于将Java对象与数据库表...

    hibernate spring

    Hibernate不仅能够简化数据持久化操作，而且支持透明持久化，让开发者无需直接面对SQL语句，同时提供了缓存机制来优化性能。 Spring是一个广泛使用的依赖注入（DI）和面向切面编程（AOP）框架，它能够帮助开发者...

    hsql及其官方说明书

    HSQldb 支持SQL:2003标准，包括完整的DML（数据操作语言）和DDL（数据定义语言）语句。用户可以使用INSERT、UPDATE、DELETE进行数据操作，CREATE TABLE、ALTER TABLE、DROP TABLE等进行数据结构的创建、修改和删除。...

    Hibernate泛型DAO及使用方法

    - `bulkUpdate(String queryString)` 和 `bulkUpdate(String queryString, Object[] values)`：执行HSQL语句进行批量更新。 - `find(String queryString)` 和 `find(String queryString, Object[] values)`：通过...

    《Hibernate入门与提高》------讲解详细，容易理解

    Hibernate是一个流行的Java对象关系映射（ORM）框架，它简化了数据库操作，使开发者可以用Java对象来处理数据，而无需直接编写SQL语句。 在第1章“Hibernate入门”中，作者首先介绍了本章的目标，即为Hibernate初学...

    Hibernate泛型DAO及使用方法.doc

    8. `find(String queryString)`：通过HSQL语句查询数据并返回结果列表。 这些方法覆盖了基本的数据操作需求，并且由于使用了泛型，使得DAO可以适应任何继承自`Serializable`的实体类，提高了代码的可重用性和灵活性...

    Hibernate泛型DAO及使用方法借鉴.pdf

    - `bulkUpdate(String queryString)`等：执行HSQL语句进行批量操作。 2. **使用LockMode** `LockMode`是Hibernate提供的锁定模式，用于控制并发访问时的数据一致性。`getWithLock`和`loadWithLock`方法使用了锁...

    hibernate方言汇总.docx和SSH的jar包名称

    这个方言参数用于指定Hibernate在生成SQL语句时所使用的数据库特性，确保SQL语句与特定数据库的兼容性。 #### Hibernate方言的作用 - **SQL语法差异处理**：不同的数据库系统有着不同的SQL语法和特性支持。例如，...

    java软件开发dao层泛型模式

    - `findByNamedParam(queryString, paramNames, values)`: 使用带有命名参数的HSQL语句查询数据。 - `findByNamedQuery(queryName)`: 使用命名的HSQL语句查询数据。 #### 四、泛型DAO的优势 1. **代码复用性**：...

    java开发操作数据库架包

    对于ORM框架如Hibernate或MyBatis，需要在配置文件中指定HSQL的数据源信息，以便框架能够正确地连接和操作数据库。 在进行数据库操作时，需要注意的一些关键点包括：事务管理、性能优化（如批处理、缓存使用）、...

    eSql语法学习资料

    ESQL类似于Hibernate中的HSQL，其语法与标准SQL非常相似，但又针对Entity Framework进行了优化和扩展。ESQL主要通过字符串形式来执行查询，这为开发者提供了更加灵活的方式来操作数据库。 #### 二、ESQL查询结果集...

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