Java HibernateQuery类代码示例

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Override
public Page<T> findAll(final Predicate predicate, final Pageable pageable, final Sort... sorts) {
	
	return hibernateTemplate.executeWithNativeSession(new HibernateCallback<Page<T>>() {
		public Page<T> doInHibernate(Session session) throws HibernateException, SQLException {
			
			HibernateQuery query = new HibernateQuery(session).from(metamodel);
			applyWhere(query, predicate);
			applySorting(query, sorts);
			applyPagination(query, pageable);
			List<T> content = query.list(metamodel);
			
			
			HibernateQuery countQuery = new HibernateQuery(session).from(metamodel);
			applyWhere(countQuery, predicate);
			long total = countQuery.count();

			return new Pagination<T>(content, pageable, total);
		}
	});
}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Test
@Transactional( readOnly = true )
public void groupingTest() {
    HibernateQuery query = new HibernateQuery(getCurrentSession());
    QEmployee employee = QEmployee.employee;
    QCompany company = QCompany.company;

    List<Tuple> loaded =
            query.from(employee)
                    .groupBy(employee.company.code, employee.empGrade.code)
                    .list(employee.company.code.as("CompanyCode"),
                          employee.empGrade.code.as("GradeCode"),
                          employee.countDistinct().as("RowCount"));

    log.info("Group by = [{}]", loaded);
}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Test
@Transactional( readOnly = true )
@SuppressWarnings( "unchecked" )
public void getHibernateQuery() {
    HibernateQuery query = new HibernateQuery(getCurrentSession());
    QEmployee employee = QEmployee.employee;
    org.hibernate.Query hibernateQuery =
            query.from(employee)
                    .where(employee.name.like("Smith%"))
                    .createQuery(employee);

    List<Employee> emps = hibernateQuery.list();

    for (Employee emp : emps)
        log.info("Employee=[{}]", emp);
}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Override
public long count(final Predicate predicate) {
	return hibernateTemplate.executeWithNativeSession(new HibernateCallback<Long>() {
		public Long doInHibernate(Session session) throws HibernateException, SQLException {
			HibernateQuery query = new HibernateQuery(session).from(metamodel);
			applyWhere(query, predicate);
			return query.count();
		}
	});
}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
/**
         * Gets company.
         *
         * @return the company
         */
        public static Company getCompany() {
            HibernateQuery query = new HibernateQuery(UnitOfWorks.getCurrentSession());
            QCompany company = QCompany.company;
            return query
                    .from(company)
                    .where(company.code.eq(getCompanyCode()))
                    .singleResult(company);
//            return (Company) UnitOfWorks.getCurrentSession()
//                    .createCriteria(Company.class)
//                    .add(Restrictions.eq("code", getCompanyCode()))
//                    .uniqueResult();
        }
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
/**
         * Gets department.
         *
         * @return the department
         */
        public static Department getDepartment() {
            HibernateQuery query = new HibernateQuery(UnitOfWorks.getCurrentSession());
            QDepartment department = QDepartment.department;

            return query.from(department)
                    .where(department.code.eq(getDepartmentCode()))
                    .singleResult(department);

//            return (Department) UnitOfWorks.getCurrentSession()
//                    .createCriteria(Department.class)
//                    .add(Restrictions.eq("code", getDepartmentCode()))
//                    .uniqueResult();
        }
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
/**
         * Gets user.
         *
         * @return the user
         */
        public static User getUser() {
            HibernateQuery query = new HibernateQuery(UnitOfWorks.getCurrentSession());
            QUser user = QUser.user;

            return query.from(user)
                    .where(user.username.eq(getUsername()))
                    .singleResult(user);

//            return (User) UnitOfWorks.getCurrentSession()
//                    .createCriteria(User.class)
//                    .add(Restrictions.eq("username", getUsername()))
//                    .uniqueResult();
        }
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Test
@Transactional( readOnly = true )
public void simpleWhere() {
    HibernateQuery query = new HibernateQuery(getCurrentSession());
    QEmployee employee = QEmployee.employee;
    Employee loaded = query.from(employee)
            .where(employee.name.eq("Smith"))
            .uniqueResult(employee);

    log.info("Employee=[{}]", loaded);
}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Test
@Transactional( readOnly = true )
public void joinWhere() {
    HibernateQuery query = new HibernateQuery(getCurrentSession());
    QEmployee employee = QEmployee.employee;
    QCompany company = QCompany.company;
    Employee loaded = query.from(employee)
            .innerJoin(employee.company, company)
            .where(employee.name.eq("Smith").and(company.code.eq("KTH")))
            .uniqueResult(employee);

    log.info("Employee=[{}]", loaded);
}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Test
@Transactional( readOnly = true )
public void subQueriesTest() {
    QDepartment department = QDepartment.department;
    QDepartmentMember member = QDepartmentMember.departmentMember;
    QDepartment d = new QDepartment("d");

    HibernateQuery query = new HibernateQuery(getCurrentSession());

    QEmployee employee = QEmployee.employee;
    QEmployee e = new QEmployee("e");

    query.from(employee)
            .where(employee.age.gt(new HibernateSubQuery().from(e).unique(e.age.avg())))
            .list(employee);

    // 직원이 가장 많은 부서 (이것은 차라리 subquery 보다 이 방식이 낫다)
    List<Long> results = query.from(member).groupBy(member.department).list(member.count());

    if (results != null && results.size() > 0) {
        Long max = (Long) results.get(0);
        List<Department> bigDepartment =
                query.from(department)
                        .where(department.members.size().eq(max.intValue()))
                        .list(department);
    }
}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Test
@Transactional( readOnly = true )
public void transformTest() {
    QCompany company = QCompany.company;
    QEmployee employee = QEmployee.employee;
    HibernateQuery query = new HibernateQuery(getCurrentSession());

    Map<Long, List<Employee>> results =
            query.from(company)
                    .innerJoin(company.employees, employee)
                    .transform(groupBy(company.id).as(list(employee)));

}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
@Test
@Transactional( readOnly = true )
public void queryCompany() {
    QCompany qCompany = QCompany.company;

    HibernateQuery query = new HibernateQuery(getCurrentSession());
    List<Company> loaded = query.from(qCompany)
            .where(qCompany.active.isTrue().and(qCompany.name.isNotEmpty()).and(qCompany.code.in("KTH", "KT")))
            .list(qCompany);

    log.debug("company={}", StringTool.listToString(loaded));
}
 

import com.mysema.query.jpa.hibernate.HibernateQuery; //导入依赖的package包/类
private HibernateQuery createQuery() {
    return new HibernateQuery(sessionFactory.getCurrentSession());
}