Java QueryHints类代码示例

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Override
public FindOIDsResult<O> findAll(final UserContext userContext) {
	CriteriaBuilder builder = _entityManager.getCriteriaBuilder();
	
	// use projections to return ONLY the oid (see http://stackoverflow.com/questions/12618489/jpa-criteria-api-select-only-specific-columns)
	CriteriaQuery<Tuple> query = builder.createTupleQuery();
	Root<DB> root = query.from(_DBEntityType);
	if (Facetables.hasFacet(_modelObjectType,HasVersionableFacet.class)) {
		query.multiselect(root.get("_oid"),
						  root.get("_version"));
	} else {
		query.multiselect(root.get("_oid"));
	}
	List<Tuple> tupleResult = _entityManager.createQuery(query)
													.setHint(QueryHints.READ_ONLY,HintValues.TRUE)
										    .getResultList();
	FindOIDsResult<O> outOids = _buildResultsFromOids(userContext,
													  tupleResult);
	return outOids;
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Test
public void test() {
    Query query = entityManager.createQuery("select p from Password p");
    query.setHint(QueryHints.LEFT_FETCH, "p.normalUser.employmentContacts");

    Field f = ReflectionUtils.findField(((EJBQueryImpl) query).getDatabaseQuery().getClass(), "joinedAttributeManager");
    f.setAccessible(true);
    JoinedAttributeManager old = (JoinedAttributeManager) ReflectionUtils.getField(f, ((EJBQueryImpl) query).getDatabaseQuery());
    FixedJoinerAttributeManager newManager = new FixedJoinerAttributeManager(old.getDescriptor(), old.getBaseExpressionBuilder(), old.getBaseQuery());
    newManager.copyFrom(old);

    ReflectionUtils.setField(f, ((EJBQueryImpl) query).getDatabaseQuery(), newManager);

    query.setMaxResults(1);

    List<Password> passwords = query.getResultList();

    Assert.assertFalse(passwords.isEmpty());

    for (Password password : passwords) {
        Assert.assertTrue(Persistence.getPersistenceUtil().isLoaded(password, "normalUser"));
        Assert.assertTrue(Persistence.getPersistenceUtil().isLoaded(password.getNormalUser(), "employmentContacts"));
    }
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Test
public void testNestedAssociationOnChildFetched() {
    Query query = entityManager.createQuery("select u from User u left join treat (u.contacts as Phone) p left join fetch p.statuses s");
    query.setHint(QueryHints.LEFT_FETCH, "u.contacts.statuses");
    List<User> users = query.getResultList();

    boolean hasStatus = false;

    Assert.assertFalse(users.isEmpty());
    for (User user : users) {
        Assert.assertTrue(Persistence.getPersistenceUtil().isLoaded(user, "contacts"));
        for (Contact contact : user.getContacts()) {
            Assert.assertTrue(Persistence.getPersistenceUtil().isLoaded(contact, "statuses"));
            if (contact instanceof Phone) {
                if (!((Phone) contact).getStatuses().isEmpty()) {
                    hasStatus = true;
                }
            }
        }
    }

    Assert.assertTrue(hasStatus);
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
public void addView(JpaQuery query, String queryString, View view, boolean singleResultExpected) {
    Preconditions.checkNotNullArgument(query, "query is null");
    Preconditions.checkNotNullArgument(view, "view is null");

    Map<String, Object> hints = query.getHints();
    AttributeGroup ag = null;
    if (view.loadPartialEntities()) {
        if (hints != null)
            ag = (FetchGroup) hints.get(QueryHints.FETCH_GROUP);
        if (ag == null)
            ag = new FetchGroup();
    } else {
        if (hints != null)
            ag = (LoadGroup) hints.get(QueryHints.LOAD_GROUP);
        if (ag == null)
            ag = new LoadGroup();
    }

    applyView(query, queryString, ag, view, singleResultExpected);
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Override
public FindOIDsResult<O> findByCreateDate(final UserContext userContext,
										  final Range<Date> createDate) {
	CriteriaBuilder builder = _entityManager.getCriteriaBuilder();
	
	// use projections to return ONLY the oid (see http://stackoverflow.com/questions/12618489/jpa-criteria-api-select-only-specific-columns)
	CriteriaQuery<Tuple> query = builder.createTupleQuery();
	Root<DB> root = query.from(_DBEntityType);
	if (Facetables.hasFacet(_modelObjectType,HasVersionableFacet.class)) {
		query.multiselect(root.get("_oid"),
						  root.get("_version"));
	} else {
		query.multiselect(root.get("_oid"));
	}
	Predicate where = _buildDateRangePredicate(builder,root,"_createDate",
											   createDate);
	if (where != null) query.where(where);
	List<Tuple> tupleResult = _entityManager.createQuery(query)
													.setHint(QueryHints.READ_ONLY,HintValues.TRUE)
										    .getResultList();
	FindOIDsResult<O> outOids = _buildResultsFromOids(userContext,
													  tupleResult);
	return outOids;
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Override
public FindOIDsResult<O> findByLastUpdateDate(final UserContext userContext,
											  final Range<Date> lastUpdateDate) {
	CriteriaBuilder builder = _entityManager.getCriteriaBuilder();
	
	// use projections to return ONLY the oid (see http://stackoverflow.com/questions/12618489/jpa-criteria-api-select-only-specific-columns)
	CriteriaQuery<Tuple> query = builder.createTupleQuery();
	Root<DB> root = query.from(_DBEntityType);
	if (Facetables.hasFacet(_modelObjectType,HasVersionableFacet.class)) {
		query.multiselect(root.get("_oid"),
						  root.get("_version"));
	} else {
		query.multiselect(root.get("_oid"));
	}
	Predicate where = _buildDateRangePredicate(builder,root,"_lastUpdateDate",
											   lastUpdateDate);
	if (where != null) query.where(where);
	List<Tuple> tupleResult = _entityManager.createQuery(query)
													.setHint(QueryHints.READ_ONLY,HintValues.TRUE)
										    .getResultList();
	FindOIDsResult<O> outOids = _buildResultsFromOids(userContext,
													  tupleResult);
	return outOids;
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Override
public FindOIDsResult<O> findByCreator(final UserContext userContext,
									   final UserCode creatorUserCode) {
	CriteriaBuilder builder = _entityManager.getCriteriaBuilder();
	
	// use projections to return ONLY the oid (see http://stackoverflow.com/questions/12618489/jpa-criteria-api-select-only-specific-columns)
	CriteriaQuery<Tuple> query = builder.createTupleQuery();
	Root<DB> root = query.from(_DBEntityType);
	if (Facetables.hasFacet(_modelObjectType,HasVersionableFacet.class)) {
		query.multiselect(root.get("_oid"),
						  root.get("_version"));
	} else {
		query.multiselect(root.get("_oid"));
	}
	Predicate where = _buildUserPredicate(builder,root,"_creator",
										  creatorUserCode);
	if (where != null) query.where(where);
	List<Tuple> tupleResult = _entityManager.createQuery(query)
													.setHint(QueryHints.READ_ONLY,HintValues.TRUE)
										    .getResultList();
	FindOIDsResult<O> outOids = _buildResultsFromOids(userContext,
													  tupleResult);
	return outOids;
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Override
public FindOIDsResult<O> findByLastUpdator(final UserContext userContext,
										   final UserCode lastUpdatorUserCode) {
	CriteriaBuilder builder = _entityManager.getCriteriaBuilder();
	
	// use projections to return ONLY the oid (see http://stackoverflow.com/questions/12618489/jpa-criteria-api-select-only-specific-columns)
	CriteriaQuery<Tuple> query = builder.createTupleQuery();
	Root<DB> root = query.from(_DBEntityType);
	if (Facetables.hasFacet(_modelObjectType,HasVersionableFacet.class)) {
		query.multiselect(root.get("_oid"),
						  root.get("_version"));
	} else {
		query.multiselect(root.get("_oid"));
	}
	Predicate where = _buildUserPredicate(builder,root,"_lastUpdator",
										  lastUpdatorUserCode);
	if (where != null) query.where(where);
	List<Tuple> tupleResult = _entityManager.createQuery(query)
													.setHint(QueryHints.READ_ONLY,HintValues.TRUE)
										    .getResultList();
	FindOIDsResult<O> outOids = _buildResultsFromOids(userContext,
													  tupleResult);
	return outOids;
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
/**
 * Return the vertex with the given data.
 */
public synchronized Vertex findByData(Object data) {
	if (data == null) {
		return null;
	}
	Vertex vertex = this.verticesByData.get(data);
	if (vertex != null) {
		return vertex;
	}
	Query query = getEntityManager().createNamedQuery("findVertexByData");
	query.setHint(QueryHints.READ_ONLY, true);
	query.setParameter("data", BasicVertex.convertDataValue(data));
	query.setParameter("type", BasicVertex.convertDataType(data));
	try {
		vertex = (Vertex)query.getSingleResult();
		if (this.verticesByData.size() < MAX_SIZE) {
			this.verticesByData.put(vertex.getData(), vertex);
		}
		return vertex;
	} catch (NoResultException notFound) {
		return null;
	}
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
/**
 *
 * @return
 */
public Long count() {
    EntityManager em = getEntityManager();
    try {
        CriteriaQuery cq = createCriteriaQuery();
        Root<T> root = cq.from(entityBeanType);
        Predicate predicate = createPredicate(root);
        if (predicate == null) {
            cq.select(getCriteriaBuilder().count(root));
        } else {
            cq.select(getCriteriaBuilder().count(root)).where(predicate);
        }
        Query q = em.createQuery(cq);
        q.setHint(QueryHints.REFRESH, HintValues.TRUE);
        Long retorno = ((Long) q.getSingleResult()).longValue();
        return retorno;
    } finally {
        closeIfNeeded(em);
    }
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Override
public boolean hasNext() {
    EntityManager em = getEntityManager();
    try {
        if (getLastResult() > 0) {
            if (firstResult >= getLastResult()) {
                return false;
            }
            if ((firstResult + maxResults) > getLastResult()) {
                setMaxResults(getLastResult() - firstResult);
            }
        }
        TypedQuery<T> query = createQuery(em);
        query.setHint(QueryHints.REFRESH, HintValues.TRUE);
        list = query.getResultList();
        setFirstResult(firstResult + maxResults);
        return !list.isEmpty();
    } finally {
        closeIfNeeded(em);
    }
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
/**
 * @return {@link JpaBaseQueryPO}
 */
public JpaBaseQueryPO assignReadOnlyResults() {

	final String methodName = "assignReadOnlyResults";

	try {
		getQuery().setHint(QueryHints.READ_ONLY, HintValues.TRUE);
	} catch (final Exception e) {

		// TODO: Can we determine query category?
		throw new PersistenceException(new JpcBasicExceptionPO().setClassName(JpaBaseQueryPO.CLASS_NAME)
				.setMethodName(methodName).setMessage(
						"The hint [" + QueryHints.READ_ONLY + "] is not supported with this query category."),
				e);
	}
	return this;
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
@Override
public List<E> findAllWithGraph(EntityGraph<E> graph) {
    String sql = "SELECT o FROM " + getTableName() + " o";

    TypedQuery<E> query = entityManager.createQuery(sql, getEntityClass());

    query.setHint(QueryHints.JPA_LOAD_GRAPH, graph);
    return query.getResultList();
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
public void setView(JpaQuery query, String queryString, @Nullable View view, boolean singleResultExpected) {
    Preconditions.checkNotNullArgument(query, "query is null");
    if (view != null) {
        AttributeGroup ag = view.loadPartialEntities() ? new FetchGroup() : new LoadGroup();
        applyView(query, queryString, ag, view, singleResultExpected);
    } else {
        query.setHint(QueryHints.FETCH_GROUP, null);
    }
}
 

import org.eclipse.persistence.config.QueryHints; //导入依赖的package包/类
public List<T> getAllResultList() {
        EntityManager em = getEntityManager();
        try {
//            this.all = true;
            TypedQuery<T> query = createQuery(em);
            query.setHint(QueryHints.REFRESH, HintValues.TRUE);
            return query.getResultList();
        } finally {
            closeIfNeeded(em);
        }
    }