下面列出了org.hibernate.Query#setBoolean ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@SuppressWarnings("unchecked")
public List<DomainName> getAllDomainNames(boolean includeDisabledOrgs)
throws DbException {
try {
Query query = null;
if (includeDisabledOrgs) {
query = session.createQuery("from DomainName");
}
else {
query = session.createQuery("from DomainName where OrganizationId in (from Organization where Enabled = ?)");
query.setBoolean(0, true);
}
return query.list();
}
catch (Exception e) {
throw handleException(e.getClass().getSimpleName() + " exception in getAllDomainNames", e);
}
}
/**
* Find by content and name
*/
public Css findByContextAndName(String context, String name) throws DatabaseException {
log.debug("findByContextAndName({},{})", context, name);
String qs = "from Css c where c.context=:context and c.name=:name and c.active=:active";
Session session = null;
try {
session = HibernateUtil.getSessionFactory().openSession();
Query q = session.createQuery(qs);
q.setString("context", context);
q.setString("name", name);
q.setBoolean("active", true);
Css ret = (Css) q.setMaxResults(1).uniqueResult();
log.debug("findByContextAndName: {}", ret);
return ret;
} catch (HibernateException e) {
throw new DatabaseException(e.getMessage(), e);
} finally {
HibernateUtil.close(session);
}
}
public Map<Long, Integer> getActualNumberRetakeHash(final String agentIdString) {
Map<Long, Integer> actualNumberRetakeHash = new HashMap<>();
final HibernateCallback<List<Object[]>> hcb = session -> {
Query q = session.createQuery(
"select a.publishedAssessmentId, count(*) from AssessmentGradingData a, StudentGradingSummaryData s " +
" where a.agentId = :agent and a.forGrade = :forgrade " +
" and a.publishedAssessmentId = s.publishedAssessmentId and a.agentId = s.agentId " +
" and a.submittedDate > s.createdDate and a.status > :status" +
" group by a.publishedAssessmentId");
q.setString("agent", agentIdString);
q.setBoolean("forgrade", true);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
List<Object[]> countList = getHibernateTemplate().execute(hcb);
for (Object[] o : countList) {
Long l = (Long) o[1];
actualNumberRetakeHash.put((Long) o[0], l.intValue());
}
return actualNumberRetakeHash;
}
@Override
public BIObjDataSet getObjectDetailDataset(Integer objectId, Session currSession) throws EMFUserError {
logger.debug("IN");
BIObjDataSet aBIObjectDataSet = null;
String hql = "from SbiObjDataSet s where s.sbiObject.biobjId = " + objectId + " AND isDetail = ? ";
Query hqlQuery = currSession.createQuery(hql);
hqlQuery.setBoolean(0, true);
SbiObjDataSet hibDs = (SbiObjDataSet) hqlQuery.uniqueResult();
if (hibDs != null) {
aBIObjectDataSet = toBIObjDataSet(hibDs);
}
logger.debug("OUT");
return aBIObjectDataSet;
}
/**
* {@inheritDoc}
*/
@Override
public List<String> getRequestedConnectionUserIdsForUser(final String userId) {
//get friends of this user [and map it automatically to the Friend object]
//updated: now just returns a List of Strings
final HibernateCallback<List<String>> hcb = session -> {
final Query q = session.getNamedQuery(QUERY_GET_FRIEND_REQUESTS_FOR_USER);
q.setParameter(USER_UUID, userId, StringType.INSTANCE);
q.setBoolean("false", Boolean.FALSE);
//q.setResultTransformer(Transformers.aliasToBean(Friend.class));
return q.list();
};
return getHibernateTemplate().execute(hcb);
}
public int getActualNumberRetake(final Long publishedAssessmentId, final String agentIdString) {
final HibernateCallback<List<Long>> hcb = session -> {
Query q = session.createQuery(
"select count(*) from AssessmentGradingData a, StudentGradingSummaryData s " +
" where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade " +
" and a.publishedAssessmentId = s.publishedAssessmentId and a.agentId = s.agentId " +
" and a.submittedDate > s.createdDate and a.status > :status");
q.setLong("id", publishedAssessmentId);
q.setString("agent", agentIdString);
q.setBoolean("forgrade", true);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
List<Long> countList = getHibernateTemplate().execute(hcb);
if (countList != null && !countList.isEmpty()) {
return Math.toIntExact(countList.get(0));
}
return 0;
}
/**
* Find current document version
*/
public NodeDocumentVersion findCurrentVersion(Session session, String docUuid) throws HibernateException {
log.debug("findCurrentVersion({})", docUuid);
String qs = "from NodeDocumentVersion ndv where ndv.parent=:parent and ndv.current=:current";
Query q = session.createQuery(qs).setCacheable(true);
q.setString("parent", docUuid);
q.setBoolean("current", true);
NodeDocumentVersion currentVersion = (NodeDocumentVersion) q.setMaxResults(1).uniqueResult();
return currentVersion;
}
public int getLateSubmissionsNumberByAgentId(final Long publishedAssessmentId, final String agentIdString, final Date dueDate) {
final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
Query q = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.submittedDate > :submitted and a.status > :status");
q.setLong("id", publishedAssessmentId);
q.setString("agent", agentIdString);
q.setBoolean("forgrade", true);
q.setDate("submitted", dueDate);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
List<AssessmentGradingData> assessmentGradings = getHibernateTemplate().execute(hcb);
return assessmentGradings.size();
}
/**
* {@inheritDoc}
*/
@Override
public int getAllUnreadMessagesCount(final String userId) {
final HibernateCallback<Number> hcb = session -> {
final Query q = session.getNamedQuery(QUERY_GET_ALL_UNREAD_MESSAGES_COUNT);
q.setParameter(UUID, userId, StringType.INSTANCE);
q.setBoolean("false", Boolean.FALSE);
return (Number) q.uniqueResult();
};
return getHibernateTemplate().execute(hcb).intValue();
}
/**
* {@inheritDoc}
*/
@Override
public int getThreadsWithUnreadMessagesCount(final String userId) {
final HibernateCallback<Number> hcb = session -> {
final Query q = session.getNamedQuery(QUERY_GET_THREADS_WITH_UNREAD_MESSAGES_COUNT);
q.setParameter(UUID, userId, StringType.INSTANCE);
q.setBoolean("false", Boolean.FALSE);
return (Number) q.uniqueResult();
};
return getHibernateTemplate().execute(hcb).intValue();
}
@SuppressWarnings("unchecked")
public List<AssessmentGradingData> getAllSubmissions(final String publishedId) {
final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
Query q = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id and a.forGrade = :forgrade and a.status > :status");
q.setLong("id", Long.parseLong(publishedId));
q.setBoolean("forgrade", true);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
return getHibernateTemplate().execute(hcb);
}
public List<AssessmentGradingData> getUnSubmittedAssessmentGradingDataList(final Long publishedAssessmentId, final String agentIdString) {
final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
Query q = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.attemptDate desc");
q.setLong("id", publishedAssessmentId);
q.setString("agent", agentIdString);
q.setBoolean("forgrade", false);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
return getHibernateTemplate().execute(hcb);
}
public List<AssessmentGradingData> getAllAssessmentGradingByAgentId(final Long publishedAssessmentId, final String agentIdString) {
final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
Query q = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.submittedDate desc");
q.setLong("id", publishedAssessmentId);
q.setString("agent", agentIdString);
q.setBoolean("forgrade", true);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
return getHibernateTemplate().execute(hcb);
}
public Double getAverageSubmittedAssessmentGrading(final Long publishedAssessmentId, final String agentId) {
Double averageScore = 0.0;
AssessmentGradingData ag = null;
final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
Query q = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.submittedDate desc");
q.setLong("id", publishedAssessmentId);
q.setString("agent", agentId);
q.setBoolean("forgrade", true);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
List<AssessmentGradingData> assessmentGradings = getHibernateTemplate().execute(hcb);
if (!assessmentGradings.isEmpty()) {
AssessmentGradingData agd;
Double cumulativeScore = new Double(0);
Iterator i = assessmentGradings.iterator();
while (i.hasNext()) {
agd = (AssessmentGradingData) i.next();
cumulativeScore += agd.getFinalScore();
}
averageScore = cumulativeScore / assessmentGradings.size();
DecimalFormat df = new DecimalFormat("0.##");
DecimalFormatSymbols dfs = new DecimalFormatSymbols();
dfs.setDecimalSeparator('.');
df.setDecimalFormatSymbols(dfs);
averageScore = new Double(df.format((double) averageScore));
}
return averageScore;
}
public Double getAverageSubmittedAssessmentGrading(final Long publishedAssessmentId, final String agentId) {
Double averageScore = 0.0;
AssessmentGradingData ag = null;
final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
Query q = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.submittedDate desc");
q.setLong("id", publishedAssessmentId);
q.setString("agent", agentId);
q.setBoolean("forgrade", true);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
List<AssessmentGradingData> assessmentGradings = getHibernateTemplate().execute(hcb);
if (!assessmentGradings.isEmpty()) {
AssessmentGradingData agd;
Double cumulativeScore = new Double(0);
Iterator i = assessmentGradings.iterator();
while (i.hasNext()) {
agd = (AssessmentGradingData) i.next();
cumulativeScore += agd.getFinalScore();
}
averageScore = cumulativeScore / assessmentGradings.size();
DecimalFormat df = new DecimalFormat("0.##");
DecimalFormatSymbols dfs = new DecimalFormatSymbols();
dfs.setDecimalSeparator('.');
df.setDecimalFormatSymbols(dfs);
averageScore = new Double(df.format((double) averageScore));
}
return averageScore;
}
public Map<Long, List<ItemGradingData>> getSubmitData(final Long publishedId, final String agentId, final Integer scoringoption, final Long assessmentGradingId) {
try {
final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
log.debug("scoringoption = " + scoringoption);
if (EvaluationModelIfc.LAST_SCORE.equals(scoringoption)) {
// last submission
Query q;
if (assessmentGradingId == null) {
q = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.submittedDate DESC");
q.setLong("id", publishedId);
q.setString("agent", agentId);
q.setBoolean("forgrade", true);
q.setInteger("status", AssessmentGradingData.REMOVED);
} else {
q = session.createQuery("from AssessmentGradingData a where a.assessmentGradingId = :id");
q.setLong("id", assessmentGradingId);
}
return q.list();
} else {
//highest submission
Query q1 = null;
if (assessmentGradingId == null) {
q1 = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id and a.agentId = :agent and a.forGrade = :forgrade and a.status > :status order by a.finalScore DESC, a.submittedDate DESC");
q1.setLong("id", publishedId);
q1.setString("agent", agentId);
q1.setBoolean("forgrade", true);
q1.setInteger("status", AssessmentGradingData.REMOVED);
} else {
q1 = session.createQuery("from AssessmentGradingData a where a.assessmentGradingId = :id");
q1.setLong("id", assessmentGradingId);
}
return q1.list();
}
};
List<AssessmentGradingData> scores = getHibernateTemplate().execute(hcb);
HashMap<Long, List<ItemGradingData>> map = new HashMap<>();
if (scores.isEmpty()) {
return new HashMap<>();
}
AssessmentGradingData gdata = scores.get(0);
Map<Long, Set<ItemGradingAttachment>> attachmentMap = getItemGradingAttachmentMapByAssessmentGradingId(
gdata.getAssessmentGradingId());
gdata.setItemGradingSet(getItemGradingSet(gdata.getAssessmentGradingId()));
for (ItemGradingData data : gdata.getItemGradingSet()) {
if (attachmentMap.get(data.getItemGradingId()) != null) {
data.setItemGradingAttachmentSet(attachmentMap.get(data.getItemGradingId()));
} else {
data.setItemGradingAttachmentSet(new HashSet<>());
}
List<ItemGradingData> thisone = map.get(data.getPublishedItemId());
if (thisone == null) {
thisone = new ArrayList<>();
}
thisone.add(data);
map.put(data.getPublishedItemId(), thisone);
}
return map;
} catch (Exception e) {
log.warn(e.getMessage(), e);
return new HashMap<>();
}
}
/**
* Counts number of existent DataSets
*
* @return Integer, number of existent DataSets
* @throws EMFUserError the EMF user error
*/
@Override
public Integer countDatasets() {
logger.debug("IN");
Session session = null;
Transaction transaction = null;
Long resultNumber;
try {
session = getSession();
transaction = session.beginTransaction();
List<Domain> devCategories = new LinkedList<Domain>();
boolean isDev = fillDevCategories(devCategories);
if (isDev) {
List idsCat = createIdsCatogriesList(devCategories);
String owner = ((UserProfile) getUserProfile()).getUserId().toString();
Query countQuery;
if (idsCat == null || idsCat.size() == 0) {
countQuery = session.createQuery("select count(*) from SbiDataSet sb where sb.active = ? and owner = :owner");
countQuery.setBoolean(0, true);
countQuery.setString("owner", owner);
} else {
countQuery = session
.createQuery("select count(*) from SbiDataSet sb where sb.active = ? and (sb.category.valueId IN (:idsCat) or owner = :owner)");
countQuery.setBoolean(0, true);
countQuery.setParameterList("idsCat", idsCat);
countQuery.setString("owner", owner);
}
resultNumber = (Long) countQuery.uniqueResult();
} else {
String hql = "select count(*) from SbiDataSet ds where ds.active = ? ";
Query hqlQuery = session.createQuery(hql);
hqlQuery.setBoolean(0, true);
resultNumber = (Long) hqlQuery.uniqueResult();
}
} catch (Throwable t) {
if (transaction != null && transaction.isActive()) {
transaction.rollback();
}
throw new SpagoBIDAOException("Error while loading the list of SbiDataSet", t);
} finally {
if (session != null && session.isOpen()) {
session.close();
}
logger.debug("OUT");
}
return new Integer(resultNumber.intValue());
}
public Set<PublishedItemData> getItemSet(final Long publishedAssessmentId, final Long sectionId) {
final HibernateCallback<List<Long>> hcb = session -> {
Query q = session.createQuery(
"select distinct p.itemId " +
"from PublishedItemData p, AssessmentGradingData a, ItemGradingData i " +
"where a.publishedAssessmentId = :id and a.forGrade = :forgrade and p.section.id = :sectionid " +
"and i.assessmentGradingId = a.assessmentGradingId " +
"and p.itemId = i.publishedItemId and a.status > :status ");
q.setLong("id", publishedAssessmentId);
q.setBoolean("forgrade", true);
q.setLong("sectionid", sectionId);
q.setInteger("status", AssessmentGradingData.REMOVED);
return q.list();
};
List<Long> itemIds = getHibernateTemplate().execute(hcb);
if (itemIds.isEmpty()) {
return new HashSet<>();
}
final HibernateCallback<List<PublishedItemData>> hcb2 = session -> {
final Criteria criteria = session.createCriteria(PublishedItemData.class);
if (itemIds.size() > 1000) {
final Set<Long> ids = new HashSet<>();
Disjunction disjunction = Restrictions.disjunction();
for (Long id : itemIds) {
if (ids.size() < 1000) {
ids.add(id);
} else {
criteria.add(disjunction.add(Restrictions.in("itemId", ids)));
ids.clear();
}
}
} else {
criteria.add(Restrictions.in("itemId", itemIds));
}
return criteria.list();
};
List<PublishedItemData> publishedItems = getHibernateTemplate().execute(hcb2);
return new HashSet<>(publishedItems);
}
/**
* for public QueryResult getList... doInHibernate
* @param query JPA-Style : from TB_ACCOUNT where account = ?0
* @param position JPA-Style : "0", "1" .....
* @param params
*/
@SuppressWarnings("rawtypes")
private void setQueryParams(Query query, String position, Object params) {
if (params instanceof java.lang.String ) {
query.setString(position, (java.lang.String)params);
return;
}
if (params instanceof java.lang.Character) {
query.setCharacter(position, (java.lang.Character)params);
return;
}
if (params instanceof java.lang.Double ) {
query.setDouble(position, (java.lang.Double)params);
return;
}
if (params instanceof java.lang.Byte ) {
query.setByte(position, (java.lang.Byte)params);
return;
}
if (params instanceof java.lang.Integer ) {
query.setInteger(position, (java.lang.Integer)params);
return;
}
if (params instanceof java.lang.Long ) {
query.setLong(position, (java.lang.Long)params);
return;
}
if (params instanceof java.lang.Boolean ) {
query.setBoolean(position, (java.lang.Boolean)params);
return;
}
if (params instanceof java.math.BigDecimal ) {
query.setBigDecimal(position, (java.math.BigDecimal)params);
return;
}
if (params instanceof java.util.Date ) {
query.setDate(position, (java.util.Date)params);
return;
}
if (params instanceof java.util.List ) {
List listParams=(List)params;
this.setQueryParamsOfList(query, position, listParams);
return;
}
}
/**
* This returns a hashmap of all the latest item entries, keyed by
* item id for easy retrieval.
*
* @param publishedId
* @param agentId
* @return
*/
public Map<Long, List<ItemGradingData>> getLastItemGradingData(final Long publishedId, final String agentId) {
try {
final HibernateCallback<List<AssessmentGradingData>> hcb = session -> {
// I am debating should I use (a.forGrade=false and a.status=NO_SUBMISSION) or attemptDate is not null
Query q = session.createQuery(
"from AssessmentGradingData a where a.publishedAssessmentId = :id " +
"and a.agentId = :agent and a.forGrade = :forgrade and a.status <> :status and a.status <> :removed " +
"order by a.submittedDate DESC");
q.setLong("id", publishedId);
q.setString("agent", agentId);
q.setBoolean("forgrade", false);
q.setInteger("status", AssessmentGradingData.NO_SUBMISSION);
q.setInteger("removed", AssessmentGradingData.REMOVED);
return q.list();
};
List<AssessmentGradingData> scores = getHibernateTemplate().execute(hcb);
if (scores.isEmpty()) {
return new HashMap<>();
}
HashMap<Long, List<ItemGradingData>> map = new HashMap<>();
AssessmentGradingData gdata = scores.get(0);
// initialize itemGradingSet
gdata.setItemGradingSet(getItemGradingSet(gdata.getAssessmentGradingId()));
if (gdata.getForGrade()) {
return new HashMap<>();
}
for (ItemGradingData data : gdata.getItemGradingSet()) {
List<ItemGradingData> thisone = map.get(data.getPublishedItemId());
if (thisone == null) {
thisone = new ArrayList<>();
}
thisone.add(data);
map.put(data.getPublishedItemId(), thisone);
}
return map;
} catch (Exception e) {
log.warn(e.getMessage(), e);
return new HashMap<>();
}
}