package com.vci.server.base.persistence.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.connection.ConnectionProvider;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.Expression;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.type.Type;

import com.vci.common.objects.UserEntity;
import com.vci.common.resource.CommonProperties;
import com.vci.server.base.persistence.event.HistoryQueryListener;
import com.vci.server.base.persistence.event.PostDeleteQueryListener;
import com.vci.server.base.persistence.event.PostUpdateQueryListener;
import com.vci.server.base.persistence.event.QueryImpl;

public class GenericHibernateDao<T extends Serializable, PK extends Serializable> implements GenericDao<T, PK> {

	// 实体类类型(由构造方法自动赋值)
	protected Class<T> entityClass;
	protected Session session;
	protected String logQuerySwitch = "off";

	public GenericHibernateDao() {
		this.entityClass = (Class<T>) ((ParameterizedType) this.getClass().getGenericSuperclass())
				.getActualTypeArguments()[0];
		this.session = HibernateSessionFactory.getSession();
		logQuerySwitch = CommonProperties.getStringProperty("log.query.switch");
	}

//---------------------基本检索、增加、修改、删除操作-----------------------------

	/**
	 * ok
	 */
	// 根据主键获取实体。如果没有相应的实体，返回null。
	@SuppressWarnings("unchecked")
	public T getById(PK id) {
		return (T) session.get(entityClass, id);
	}

	// 根据主键获取实体并加锁。如果没有相应的实体，返回null。
	@SuppressWarnings("unchecked")
	public T getByIdWithLock(PK id, LockMode lock) {
		T t = (T) session.get(entityClass, id, lock);
		if (t != null) {
			this.flush(); // 立即刷新，否则锁不会生效。
		}

		return t;
	}

	// 根据主键获取实体。如果没有相应的实体，抛出异常
	@SuppressWarnings("unchecked")
	public T loadById(PK id) {
		return (T) session.load(entityClass, id);
	}

	// 根据主键获取实体并加锁。如果没有相应的实体，抛出异常
	@SuppressWarnings("unchecked")
	public T loadByIdWithLock(PK id, LockMode lock) {
		T t = (T) session.load(entityClass, id);
		if (t != null) {
			this.flush(); // 立即刷新，否则锁不会生效。
		}

		return t;
	}

	// 获取全部实体
	@SuppressWarnings("unchecked")
	public List<T> loadAll() {
//		return session.createCriteria(entityClass).list();
		List<T> list = session.createQuery("from " + entityClass.getName()).list();
		return list;
	}

	// 获得指定页的实体
	@SuppressWarnings("unchecked")
	public List<T> findList(int pageNo, int pageSize) {
		return session.createCriteria(entityClass).setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize)
				.list();
	}

    
    //获得指定页的实体
    @SuppressWarnings("unchecked")
	public List<T> findList(int pageNo, int pageSize, Order order) {
			return session.createCriteria(entityClass)
			        .setFirstResult((pageNo - 1) * pageSize)
			        .setMaxResults(pageSize).addOrder(order).list();
	}

	// added by xiong fei 2011-02-14 日志查询
	@SuppressWarnings("unchecked")
	public List<T> findList(int pageNo, int pageSize, String sql, Order order) {
		if (order == null) {
			return session.createCriteria(entityClass).setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize)
					.add(Expression.sqlRestriction(sql)).list();
		} else {
			return session.createCriteria(entityClass).setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize)
					.add(Expression.sqlRestriction(sql)).addOrder(order).list();
		}
	}

	// 获得存储对象的个数
	public int getCount() {
		Integer count = (Integer) session.createCriteria(entityClass).setProjection(Projections.rowCount())
				.uniqueResult();
		if (null == count) {
			return 0;
		} else {
			return count.intValue();
		}
	}

	// added by xiong fei 2011-02-14 日志查询
	public long getCountForLog(String sql) {
		Long count = (Long) session.createCriteria(entityClass).add(Expression.sqlRestriction(sql))
				.setProjection(Projections.rowCount()).uniqueResult();
		if (null == count) {
			return 0;
		} else {
			return count.longValue();
		}
	}

	// 更新实体
	public void update(T entity) {
		session.update(entity);
		this.flush();
	}

	// 更新实体并加锁
	public void updateWithLock(T entity, LockMode lock) {
		session.update(entity);
		this.flush();
	}

	// 存储实体到数据库
	public void save(T entity) {
		session.save(entity);
		this.flush();
	}

	// 增加或更新实体
	public void saveOrUpdate(T entity) {
		session.saveOrUpdate(entity);
		this.flush();
	}

	// 增加或更新集合中的全部实体
	public void saveOrUpdateAll(Collection<T> entities) {
		for (T t : entities) {
			session.saveOrUpdate(t);
		}
		this.flush();
	}

	// 删除指定的实体
	public void delete(T entity) {
		session.delete(entity);
		this.flush();
	}

	// 根据主键删除指定的实体
	public void deleteByKey(PK id) {
		this.delete(this.loadById(id));
		this.flush();
	}

	// 删除集合中的全部实体
	public void deleteAll(Collection<T> entities) {
		this.flush();
		session.delete(entities);
	}

	public T merge(T entity) {
		return (T) session.merge(entity);
	}

	// -----------------------------HSQL------------------------------
	// 使用hql进行删除和更新操作，未记录更新日志
	public void createQuery(String hql) {
		Query query = session.createQuery(hql);
		query.executeUpdate();
	}

	// 使用hql进行删除和更新操作，未记录更新日志
	public void createQuery(String hql, Object[] values) {
		Query query = session.createQuery(hql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		query.executeUpdate();
	}

	// 使用hql进行删除和更新操作，未记录更新日志
	public void createQuery(String hql, String[] names, Object[] values) {
		Query query = session.createQuery(hql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(names[i], values[i]);
		}
		query.executeUpdate();
	}

	/**
	 * 删除指定ID对象，并记录日志
	 * 
	 * @param hql，hql               语句
	 * @param idName，id对应在hql语句中的名称
	 * @param id，                   id的值
	 * @param userEntity，用户信息
	 */
	public void deleteQueryObject(String hql, String idName, String id, UserEntity userEntity) {
		Query query = session.createQuery(hql);
		Object obj = session.get(entityClass, id);
		query.setParameter(idName, id);
		int count = query.executeUpdate();
		if (count < 1) {
			return;
		}
		if (logQuerySwitch == null || !logQuerySwitch.equalsIgnoreCase("on")) {
			return;
		}
		PostDeleteQueryListener listener = new HistoryQueryListener();
		QueryImpl impl = new QueryImpl(listener);
		impl.deletQueryById(session, "id", id, obj, userEntity);
	}

	/**
	 * 批量删除指定ID的对象，并记录日志
	 * 
	 * @param hql，hql语句
	 * @param ids，id的数组信息
	 * @param userEntity，用户信息
	 */
	public void deleteQueryObject(String hql, String[] ids, UserEntity userEntity) {
		Query query = session.createQuery(hql);
		int len = ids.length;
		Object[] objs = new Object[ids.length];
		for (int i = 0; i < len; i++) {
			query.setParameter(i, ids[i]);
			objs[i] = session.get(entityClass, ids[i]);
		}
		int count = query.executeUpdate();
		if (count < 1) {
			return;
		}
		if (logQuerySwitch == null || !logQuerySwitch.equalsIgnoreCase("on")) {
			return;
		}

		PostDeleteQueryListener listener = new HistoryQueryListener();
		QueryImpl impl = new QueryImpl(listener);
		impl.deleteQueryByIds(session, "id", ids, objs, userEntity);
	}

	/**
	 * 通过指定属性信息进行对象删除，并记录日志
	 * 
	 * @param hql，hql语句
	 * @param props，hql语句中的属性名称
	 * @param values，hql语句中属性值
	 * @param userEntity，用户信息
	 */
	public void deleteQueryObject(String hql, String[] props, String[] values, UserEntity userEntity) {
		Query query = session.createQuery(hql);
		int len = props.length;
		for (int i = 0; i < len; i++) {
			query.setParameter(props[i], values[i]);
		}
		int count = query.executeUpdate();
		if (count < 1) {
			return;
		}
		if (logQuerySwitch == null || !logQuerySwitch.equalsIgnoreCase("on")) {
			return;
		}

		PostDeleteQueryListener listener = new HistoryQueryListener();
		QueryImpl impl = new QueryImpl(listener);
		impl.deleteQueryByProps(session, props, values, entityClass.getSimpleName(), userEntity);
	}

	/**
	 * 根据ID更新指定属性的属性值，并记录更改日志
	 * 
	 * @param hql，hql语句
	 * @param id，更新对象的id值
	 * @param props，hql语句中对应的属性名称
	 * @param values，hql语句中对应的属性值
	 * @param userEntity，用户信息
	 */
	public void updateQueryObject(String hql, String id, String[] props, String[] values, UserEntity userEntity) {
		Query query = session.createQuery(hql);
		int len = props.length;
		for (int i = 0; i < len; i++) {
			query.setParameter(props[i], values[i]);
		}
		int count = query.executeUpdate();
		if (count < 1) {
			return;
		}
		if (logQuerySwitch == null || !logQuerySwitch.equalsIgnoreCase("on")) {
			return;
		}
		Object obj = session.get(entityClass, id);
		PostUpdateQueryListener listener = new HistoryQueryListener();
		QueryImpl impl = new QueryImpl(listener);
		impl.updateQueryById(session, userEntity, id, props, values, obj);
	}

	/** lizf 以下操作采用JDBC连接数据库 **/
	/**
	 * 根据SQL语句创建、删除、更新 数据表 return 0 成功创建 -1 创建失败 -2 数据库已经存在该表
	 */
	public int oprateTable(String sTableName, String sSQL) {
		Statement statement = null;
		Connection conn = null;
		int ncheck = -1;
		try {
			ConnectionProvider cp = ((SessionFactoryImplementor) session.getSessionFactory()).getConnectionProvider();
			conn = cp.getConnection();

			boolean checkTableExist = checkTableExist(conn, sTableName);
			if (checkTableExist) {
				ncheck = -2;
				return ncheck;
			}
			statement = conn.createStatement();
			conn.commit();
			statement.executeUpdate(sSQL);
			ncheck = 0;
		} catch (SQLException e) {
			try {
				conn.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				if (conn != null) {
					conn.close();
				}
				if (statement != null) {
					statement.close();
				}
			} catch (SQLException e) {
			}
		}
		return ncheck;
	}

	/**
	 * 
	 * 根据SQL语句创建、删除、更新 数据表 return 0 成功创建 -1 创建失败 -2 数据库已经存在该表
	 *
	 * @param conn
	 * @param sTableName
	 * @param sSQL
	 * @return
	 */
	public int oprateTable(Connection conn, String sTableName, String sSQL) {
		Statement statement = null;
		int ncheck = -1;
		try {
			boolean checkTableExist = checkTableExist(conn, sTableName);
			if (checkTableExist) {
				ncheck = -2;
				return ncheck;
			}
			statement = conn.createStatement();
			conn.commit();
			statement.executeUpdate(sSQL);
			ncheck = 0;
		} catch (SQLException e) {
			try {
				conn.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				if (statement != null) {
					statement.close();
				}
			} catch (SQLException e) {
			}
		}
		return ncheck;
	}

	/**
	 * 校验当前创建的表是不是存在
	 */
	private boolean checkTableExist(Connection conn, String tableName) {
		boolean bCheck = false;
		DatabaseMetaData meta = null;
		ResultSet rs = null;
		try {
			meta = conn.getMetaData();
			rs = meta.getTables(null, null, tableName, new String[] { "TABLE" });
			if (rs.next()) {
				bCheck = true;
			} else {
				bCheck = false;
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return bCheck;
	}

	/** lizf 以上操作采用JDBC连接数据库 **/

	/**
	 * ok
	 */
	// 使用HSQL语句进行对象查询
	@SuppressWarnings("unchecked")
	public T findEntity(String hsql) {
		return (T) session.createQuery(hsql).uniqueResult();
	}

	// 使用HSQL以及单属性条件进行对象查询
	@SuppressWarnings("unchecked")
	public T findEntity(String hsql, String name, String value) {
		return (T) session.createQuery(hsql).setString(name, value).uniqueResult();
	}

	/**
	 * ok
	 */
	// 使用HSQL语句查询对象集合
	@SuppressWarnings("unchecked")
	public List<T> findEntities(String hsql) {
		return session.createQuery(hsql).list();
	}

	/**
	 * ok
	 */
	// 使用HSQL语句查询对象集合
	@SuppressWarnings("unchecked")
	public List<T> findEntities(String hsql, String name, String value) {
		return session.createQuery(hsql).setString(name, value).list();
	}

	/**
	 * ok
	 */
	// 使用带参数的HSQL语句检索数据
	@SuppressWarnings("unchecked")
	public List<T> findEntites(String hsql, Object[] values) {
		Query query = session.createQuery(hsql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		List list = query.list();
		return list;
	}

	// 根据HSQL语句获取符合要求的对象
	public List createQueryList(String hsql) {
		Query query = session.createQuery(hsql);
		List list = query.list();
		return list;
	}

	// 根据HSQL语句获取符合要求的对象
	public List createQueryList(String hsql, Object[] values) {
		Query query = session.createQuery(hsql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		List list = query.list();
		return list;
	}

	@SuppressWarnings("unchecked")
	public T findEntity(String hsql, Object[] values) {
		Query query = session.createQuery(hsql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		return (T) query.uniqueResult();
	}

	/**
	 * ok
	 */
	@SuppressWarnings("unchecked")
	public List<T> findEntites(String hsql, int start, int number) {
		Query query = session.createQuery(hsql);
		query.setFirstResult(start);
		query.setMaxResults(number);
		List list = query.list();
		return list;
	}

	/**
	 * ok
	 */
	@SuppressWarnings("unchecked")
	public List<T> findEntites(String hsql, int start, int number, Object[] values) {
		Query query = session.createQuery(hsql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		query.setFirstResult(start);
		query.setMaxResults(number);
		List list = query.list();
		return list;
	}

	// 使用命名的HSQL语句检索数据
	@SuppressWarnings("unchecked")
	public List<T> findByNamedQuery(String queryName) {
		return session.getNamedQuery(queryName).list();
	}

	// 使用带参数的命名HSQL语句检索数据
	@SuppressWarnings("unchecked")
	public List<T> findByNamedQuery(String queryName, Object[] values) {
		Query query = session.getNamedQuery(queryName);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		return query.list();
	}

	// 使用带命名参数的命名HSQL语句检索数据
	@SuppressWarnings("unchecked")
	public List<T> findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values) {
		Query query = session.getNamedQuery(queryName);
		for (int i = 0; i < paramNames.length; i++) {
			query.setParameter(paramNames[i], values[i]);
		}
		return query.list();
	}

	// 使用HSQL语句检索数据，返回Iterator
	public Iterator iterate(String queryString) {
		return session.createQuery(queryString).iterate();
	}

	// 使用带参数HSQL语句检索数据，返回Iterator
	public Iterator iterate(String queryString, Object[] values) {
		Query query = session.createQuery(queryString);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		return query.iterate();
	}

	// ---------------------------------------------Criteria------------------------

	// 创建与会话无关的检索标准对象
	public DetachedCriteria createDetachedCriteria() {
		return DetachedCriteria.forClass(this.entityClass);
	}

	// 创建与会话绑定的检索标准对象
	public Criteria createCriteria() {
		return this.createDetachedCriteria().getExecutableCriteria(session);
	}

	// 使用指定的检索标准检索数据
	@SuppressWarnings("unchecked")
	public List<T> findByCriteria(DetachedCriteria criteria) {
		return criteria.getExecutableCriteria(session).list();
	}

	// 使用指定的检索标准检索数据，返回部分记录
	@SuppressWarnings("unchecked")
	public List<T> findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults) {
		return criteria.getExecutableCriteria(session).setFirstResult(firstResult).setMaxResults(maxResults).list();
	}

	@SuppressWarnings("unchecked")
	public List<T> findByCriteria(Criterion... criterion) {
		Criteria crit = session.createCriteria(entityClass);

		for (Criterion c : criterion) {
			if (c != null) {
				crit.add(c);
			}
		}

		return crit.list();
	}

	// 使用指定的检索标准检索数据，返回指定范围的记录
	public Integer getRowCount(DetachedCriteria criteria) {
		criteria.setProjection(Projections.rowCount());
		List list = this.findByCriteria(criteria, 0, 1);
		return (Integer) list.get(0);
	}

	// 使用指定的检索标准检索数据，返回指定统计值
	public Object getStatValue(DetachedCriteria criteria, String propertyName, String StatName) {
		if (StatName.toLowerCase().equals("max")) {
			criteria.setProjection(Projections.max(propertyName));
		} else if (StatName.toLowerCase().equals("min")) {
			criteria.setProjection(Projections.min(propertyName));
		} else if (StatName.toLowerCase().equals("avg")) {
			criteria.setProjection(Projections.avg(propertyName));
		} else if (StatName.toLowerCase().equals("sum")) {
			criteria.setProjection(Projections.sum(propertyName));
		} else {
			return null;
		}

		List list = this.findByCriteria(criteria, 0, 1);
		return list.get(0);

	}

	// 通过给定的一个对象，查找与其匹配的对象，表关联比较多时，用户可以根据需要扩展
	@SuppressWarnings("unchecked")
	public List<T> findByExample(T entity) {
		Criteria crit = session.createCriteria(entityClass);
		Example example = Example.create(entity);
		example.ignoreCase().enableLike(MatchMode.ANYWHERE);// 忽略大小写，并进行模糊比辿
		example.excludeZeroes();// 对于属性中有数字类型的，如果entity的属性值为0，就把它添加到查询中
		crit.add(example);
		return crit.list();
	}

	// ---------------------------------SQL------------------------------------
	/**
	 * 使用SQL进行删除和更新
	 * <p>
	 * Description:
	 * </p>
	 * 
	 * @author xchao
	 * @time 2012-5-29
	 * @param sql
	 */
	public void createSQLQuery(String sql) {
		SQLQuery query = session.createSQLQuery(sql);
		query.executeUpdate();
	}

	/**
	 * 使用SQL进行删除和更新，占位符参数传递
	 * <p>
	 * Description:
	 * </p>
	 * 
	 * @author xchao
	 * @time 2012-5-29
	 * @param sql
	 * @param values
	 */
	public void createSQLQuery(String sql, Object[] values) {
		SQLQuery query = session.createSQLQuery(sql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		query.executeUpdate();
	}

	/**
	 * 使用SQL进行删除和更新，命名参数传递
	 * <p>
	 * Description:
	 * </p>
	 * 
	 * @author xchao
	 * @time 2012-5-29
	 * @param sql
	 * @param names
	 * @param values
	 */
	public void createSQLQuery(String sql, String[] names, Object[] values) {
		SQLQuery query = session.createSQLQuery(sql);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(names[i], values[i]);
		}
		query.executeUpdate();
	}

	/**
	 * 通过sql语句批量删除数据库数据
	 */
	public void deleteEntityBySQL(Connection connection, String sql, String[] values) throws SQLException {
		PreparedStatement stmt = null;
		try {
			stmt = connection.prepareStatement(sql);
			int len = values.length;
			for (int i = 0; i < len; i++) {
				stmt.setString(i + 1, values[i]);
			}
			stmt.executeUpdate();
		} finally {
			try {
				if (stmt != null) {
					stmt.close();
				}
			} catch (SQLException e) {
			}
		}
	}

	/**
	 * 
	 * <p>
	 * Description: 根据传输的sql语句以及sql语句中的参数，通过jdbc获取符合条件的结果集合，并把结果集合返回
	 * </p>
	 * 
	 * @author Administrator
	 * @time 2011-7-21
	 * @param sql：sql查询语句
	 * @param values：sql语句中的参数
	 * @param columns：需要返回的列，如果没有返回列，则返回所有查询出来的列
	 * @return
	 * @throws SQLException
	 */
	@Deprecated
	public Object[][] findObjectsBySQL(String sql, String[] values, String[] columns) throws SQLException {
		Connection conn = null;
		PreparedStatement stmt = null;
		ResultSet rs = null;
		Object[][] objs = null;

		try {
			// modify by xchao 2012.05.28
			ConnectionProvider cp = ((SessionFactoryImplementor) session.getSessionFactory()).getConnectionProvider();
			conn = cp.getConnection();
			stmt = conn.prepareStatement(sql);
			int len = values.length;
			for (int i = 0; i < len; i++) {
				stmt.setString(i + 1, values[i]);
			}

			rs = stmt.executeQuery();
			len = columns.length;
			if (len == 0) {
				ResultSetMetaData rsm = rs.getMetaData();
				len = rsm.getColumnCount();
				columns = new String[len];
				for (int i = 0; i < len; i++) {
					columns[i] = rsm.getColumnName(i + 1);
					String column = rsm.getColumnName(i + 1);
					if (column.lastIndexOf(" ") > 0) { // SQL中的列带别名，则只取别名
						String[] strs = column.split(" ");
						column = strs[strs.length - 1];
					}
				}
			}
			Object[] rsArray = null;
			ArrayList<Object[]> list = new ArrayList<Object[]>();
			while (rs.next()) {
				rsArray = new Object[len];
				for (int i = 0; i < len; i++) {
					rsArray[i] = rs.getObject(columns[i]);
				}
				list.add(rsArray);
			}
			int size = list.size();
			objs = list.toArray(new Object[size][]);
		} finally {
			try {
				if (conn != null) {
					conn.close();
				}
				if (stmt != null) {
					stmt.close();
				}
				if (rs != null) {
					rs.close();
				}
			} catch (SQLException e) {
			}
		}

		return objs;
	}

	public List<T> findEntites(String sql, Object[] values, String param, Class cls) {
		Query query = session.createSQLQuery(sql).addEntity(param, cls);
		for (int i = 0; i < values.length; i++) {
			query.setParameter(i, values[i]);
		}
		List list = query.list();
		return list;
	}

	public List findEntitesBySQL(String sql, Object[] values, Map<String, Type> map) {
		SQLQuery s = (SQLQuery) session.createSQLQuery(sql);
		for (int i = 0; i < values.length; i++) {
			s.setParameter(i, values[i]);
		}
		Iterator itor = map.keySet().iterator();
		while (itor.hasNext()) {
			String key = (String) itor.next();
			Type value = map.get(key);
			s.addScalar(key, value);
		}
		List list = s.list();
		return list;
	}

	/**
	 * 检查对象中是否包含指定的数据
	 * 
	 * @param tableName 表名
	 * @param valueMaps key:列名 value:值
	 * @return
	 */
	public boolean hasValue(String tableName, HashMap<String, String> valueMaps) {
		boolean res = false;
		if (tableName.equals("") || tableName == null || valueMaps.size() == 0)
			return res;
		String sql = "select cmoid from " + tableName + " where 1=1 ";
		java.util.Set<String> keys = valueMaps.keySet();
		java.util.Iterator<String> it = keys.iterator();
		while (it.hasNext()) {
			String key = it.next();
			String value = valueMaps.get(key);
//    		sql += " and '''' || " + key + " || '''' = '''" + value + "'''";
			sql += " and " + key + " = '" + value + "'";
		}
		Query q = session.createSQLQuery(sql);
		List l = q.list();
		res = l.size() != 0;
		return res;
	}

	// -------------------------------- Others --------------------------------

	// 加锁指定的实体
	public void lock(T entity, LockMode lockMode) {
		session.lock(entity, lockMode);
	}

	// 强制立即更新缓冲数据到数据库（否则仅在事务提交时才更新）
	public void flush() {
		session.flush();
	}

	// 清空缓存
	public void clear() {
		session.clear();
	}
}