public static <T> void setResultTransformer(final Class<T> entityClass, final Query query) {
if (entityClass != null) {
if (entityClass.equals(Map.class)) {
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
} else {
query.setResultTransformer(Transformers.aliasToBean(entityClass));
}
}
}
private Query createQuery(
String queryString, @Nullable QueryModifiers modifiers, boolean forCount) {
Query query = session.createQuery(queryString);
HibernateUtil.setConstants(query, getConstants(), getMetadata().getParams());
if (fetchSize > 0) {
query.setFetchSize(fetchSize);
}
if (timeout > 0) {
query.setTimeout(timeout);
}
if (cacheable != null) {
query.setCacheable(cacheable);
}
if (cacheRegion != null) {
query.setCacheRegion(cacheRegion);
}
if (comment != null) {
query.setComment(comment);
}
if (readOnly != null) {
query.setReadOnly(readOnly);
}
for (Map.Entry<Path<?>, LockMode> entry : lockModes.entrySet()) {
query.setLockMode(entry.getKey().toString(), entry.getValue());
}
if (flushMode != null) {
query.setFlushMode(flushMode);
}
if (modifiers != null && modifiers.isRestricting()) {
if (modifiers.getLimit() != null) {
query.setMaxResults(modifiers.getLimit().intValue());
}
if (modifiers.getOffset() != null) {
query.setFirstResult(modifiers.getOffset().intValue());
}
}
// set transformer, if necessary
List<? extends Expression<?>> projection = getMetadata().getProjection();
if (projection.size() == 1 && !forCount) {
Expression<?> expr = projection.get(0);
if (expr instanceof FactoryExpression<?>) {
query.setResultTransformer(
new FactoryExpressionTransformer((FactoryExpression<?>) projection.get(0)));
}
} else if (!forCount) {
FactoryExpression<?> proj = FactoryExpressionUtils.wrap(projection);
if (proj != null) {
query.setResultTransformer(new FactoryExpressionTransformer(proj));
}
}
return query;
}
/**
* Get time information from a named query
*
* @param seriesId Series id
* @param seriesMinMaxTransformer Hibernate result transformator for min/max time value
* @param session Hibernate Session
* @return Time period
*/
private TimePeriod getTimePeriodFromNamedQuery(
long seriesId, SeriesMinMaxTransformer seriesMinMaxTransformer, Session session) {
Query namedQuery = session.getNamedQuery(SQL_QUERY_GET_DATA_AVAILABILITY_FOR_SERIES);
namedQuery.setParameter(SeriesObservationInfo.SERIES, seriesId);
LOGGER.debug("QUERY getTimePeriodFromNamedQuery(series) with NamedQuery: {}", namedQuery);
namedQuery.setResultTransformer(seriesMinMaxTransformer);
return (TimePeriod) namedQuery.uniqueResult();
}
private List<?> executeNamedQuery(GetDataAvailabilityRequest req, Session session) {
final boolean features = req.isSetFeaturesOfInterest();
final boolean observableProperties = req.isSetObservedProperties();
final boolean procedures = req.isSetProcedures();
String namedQueryName = null;
Map<String, Collection<String>> parameter = Maps.newHashMap();
// all
if (features && observableProperties && procedures) {
namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_PROCEDURES_OBSERVED_PROPERTIES;
parameter.put(FEATURES, req.getFeaturesOfInterest());
parameter.put(OBSERVABLE_PROPERTIES, req.getObservedProperties());
parameter.put(PROCEDURES, req.getProcedures());
}
// observableProperties and procedures
else if (!features && observableProperties && procedures) {
namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_PROCEDURES_OBSERVED_PROPERTIES;
parameter.put(OBSERVABLE_PROPERTIES, req.getObservedProperties());
parameter.put(PROCEDURES, req.getProcedures());
}
// only observableProperties
else if (!features && observableProperties && !procedures) {
namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_OBSERVED_PROPERTIES;
parameter.put(OBSERVABLE_PROPERTIES, req.getObservedProperties());
}
// only procedures
else if (!features && !observableProperties && procedures) {
namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_PROCEDURES;
parameter.put(PROCEDURES, req.getProcedures());
}
// features and observableProperties
else if (features && observableProperties && !procedures) {
namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_OBSERVED_PROPERTIES;
parameter.put(FEATURES, req.getFeaturesOfInterest());
parameter.put(OBSERVABLE_PROPERTIES, req.getObservedProperties());
}
// features and procedures
else if (features && !observableProperties && procedures) {
namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_PROCEDURES;
parameter.put(FEATURES, req.getFeaturesOfInterest());
parameter.put(PROCEDURES, req.getProcedures());
}
// only features
else if (features && !observableProperties && procedures) {
namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES;
parameter.put(FEATURES, req.getFeaturesOfInterest());
}
if (StringHelper.isNotEmpty(namedQueryName)) {
Query namedQuery = session.getNamedQuery(namedQueryName);
for (String key : parameter.keySet()) {
namedQuery.setParameterList(key, parameter.get(key));
}
LOGGER.debug(
"QUERY getProceduresForFeatureOfInterest(feature) with NamedQuery: {}", namedQuery);
namedQuery.setResultTransformer(new DataAvailabilityTransformer(session));
return namedQuery.list();
}
return Lists.newLinkedList();
}
@Test
@TestForIssue(jiraKey = "HHH-3694")
public void testResultTransformerIsAppliedToScrollableResults() throws Exception {
Session s = openSession();
Transaction tx = s.beginTransaction();
PartnerA a = new PartnerA();
a.setName("Partner A");
PartnerB b = new PartnerB();
b.setName("Partner B");
Contract obj1 = new Contract();
obj1.setName("Contract");
obj1.setA(a);
obj1.setB(b);
s.save(a);
s.save(b);
s.save(obj1);
tx.commit();
s.close();
s = openSession();
Query q = s.getNamedQuery(Contract.class.getName() + ".testQuery");
q.setFetchSize(100);
q.setResultTransformer(
new ResultTransformer() {
private static final long serialVersionUID = -5815434828170704822L;
public Object transformTuple(Object[] arg0, String[] arg1) {
// return only the PartnerA object from the query
return arg0[1];
}
@SuppressWarnings("unchecked")
public List transformList(List arg0) {
return arg0;
}
});
ScrollableResults sr = q.scroll();
// HANA supports only ResultSet.TYPE_FORWARD_ONLY and
// does not support java.sql.ResultSet.first()
if (getDialect() instanceof AbstractHANADialect) {
sr.next();
} else {
sr.first();
}
Object[] row = sr.get();
assertEquals(1, row.length);
Object obj = row[0];
assertTrue(obj instanceof PartnerA);
PartnerA obj2 = (PartnerA) obj;
assertEquals("Partner A", obj2.getName());
s.close();
}
public List<Map<String, Object>> findBySqlList(String sql) {
List<Map<String, Object>> list = null;
if (StringUtils.isNotBlank(sql)) {
Query query = getDefaultSession().createSQLQuery(sql);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
list = query.list();
}
return list;
}
public List<Arquivo> getArquivos(Professor object) {
String hqlQuery = "SELECT arquivo FROM Arquivo arquivo WHERE professor.id = " + object.getId();
Query query = dao.getHibernateSession().createQuery(hqlQuery);
query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
log.info("query.list*(");
List<Arquivo> listaArquivosComParam = query.list();
log.info("teste" + listaArquivosComParam);
log.info("Tamanho da Lista: " + listaArquivosComParam.size());
return listaArquivosComParam;
}
@SuppressWarnings("unchecked")
public static List<Game> getCompleteGamesList() {
List<Game> games = new ArrayList<Game>();
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
try {
Query query = session.createQuery(Constants.HQL.GET_GAMES_COMPLETE);
games = (List<Game>) query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
}
session.close();
return games;
}
public <T> TypedQuery<T> createQuery(
String jpaqlString, Class<T> resultClass, Selection selection, Options options) {
try {
org.hibernate.Query hqlQuery = getSession().createQuery(jpaqlString);
if (options.getValueHandlers() == null) {
options.getResultMetadataValidator().validate(hqlQuery.getReturnTypes());
}
// determine if we need a result transformer
List tupleElements =
Tuple.class.equals(resultClass)
? ((CompoundSelectionImpl<Tuple>) selection).getCompoundSelectionItems()
: null;
if (options.getValueHandlers() != null || tupleElements != null) {
hqlQuery.setResultTransformer(
new CriteriaQueryTransformer(options.getValueHandlers(), tupleElements));
}
return new QueryImpl<T>(hqlQuery, this, options.getNamedParameterExplicitTypes());
} catch (HibernateException he) {
throw convert(he);
}
}
public void testMappedAliasStrategy() {
Session s = openSession();
Transaction t = s.beginTransaction();
Organization ifa = new Organization("IFA");
Organization jboss = new Organization("JBoss");
Person gavin = new Person("Gavin");
Employment emp = new Employment(gavin, jboss, "AU");
Serializable orgId = s.save(jboss);
Serializable orgId2 = s.save(ifa);
s.save(gavin);
s.save(emp);
t.commit();
s.close();
s = openSession();
t = s.beginTransaction();
Query namedQuery = s.getNamedQuery("AllEmploymentAsMapped");
List list = namedQuery.list();
assertEquals(1, list.size());
Employment emp2 = (Employment) list.get(0);
assertEquals(emp2.getEmploymentId(), emp.getEmploymentId());
assertEquals(emp2.getStartDate().getDate(), emp.getStartDate().getDate());
assertEquals(emp2.getEndDate(), emp.getEndDate());
t.commit();
s.close();
s = openSession();
t = s.beginTransaction();
Query sqlQuery = s.getNamedQuery("EmploymentAndPerson");
sqlQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
list = sqlQuery.list();
assertEquals(1, list.size());
Object res = list.get(0);
assertClassAssignability(res.getClass(), Map.class);
Map m = (Map) res;
assertEquals(2, m.size());
t.commit();
s.close();
s = openSession();
t = s.beginTransaction();
sqlQuery = s.getNamedQuery("organizationreturnproperty");
sqlQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
list = sqlQuery.list();
assertEquals(2, list.size());
m = (Map) list.get(0);
assertEquals(2, m.size());
assertTrue(m.containsKey("org"));
assertTrue(m.containsKey("emp"));
assertClassAssignability(m.get("org").getClass(), Organization.class);
if (jboss.getId() == ((Organization) m.get("org")).getId()) {
assertClassAssignability(m.get("emp").getClass(), Employment.class);
}
Map m2 = (Map) list.get(1);
assertEquals(2, m.size());
assertTrue(m2.containsKey("org"));
assertTrue(m2.containsKey("emp"));
assertClassAssignability(m2.get("org").getClass(), Organization.class);
if (jboss.getId() == ((Organization) m2.get("org")).getId()) {
assertClassAssignability(m2.get("emp").getClass(), Employment.class);
}
t.commit();
s.close();
s = openSession();
t = s.beginTransaction();
namedQuery = s.getNamedQuery("EmploymentAndPerson");
list = namedQuery.list();
assertEquals(1, list.size());
Object[] objs = (Object[]) list.get(0);
assertEquals(2, objs.length);
emp2 = (Employment) objs[0];
gavin = (Person) objs[1];
s.delete(emp2);
s.delete(jboss);
s.delete(gavin);
s.delete(ifa);
t.commit();
s.close();
}
/**
* 根据回复内容,推送给对应老师或家长
*
* @param msg
* @return
*/
public void pushMsg_replay_to_classNews_to_teacherOrParent(String type_uuid, String msg)
throws Exception {
Session session = this.nSimpleHibernateDao.getSession();
String sql = " SELECT t1.uuid,t1.create_useruuid,t1.usertype,t1.groupuuid";
sql += " FROM px_classnews t1 ";
sql += " where t1.uuid='" + type_uuid + "' ";
Query query = session.createSQLQuery(sql);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
List<Map> list = query.list();
if (list.size() == 0) return;
Map obj = list.get(0);
if (obj.get("usertype") == null) {
logger.error("px_classnews usertype is null,uuid" + type_uuid);
return;
}
if ("1".equals((obj.get("usertype").toString()))) {
// 家长,暂时不开发通知
return;
}
boolean isSendPushMsg = true;
List users = new ArrayList();
users.add(obj.get("create_useruuid"));
List<PushMessage> listPushMessage =
this.getPushMessageList(SystemConstants.common_type_hudong, type_uuid, users);
PushMessage pushMessage = null;
if (listPushMessage.size() > 0) {
pushMessage = listPushMessage.get(0);
}
// PushMessage pushMessage = (PushMessage) this.nSimpleHibernateDao
// .getObjectByAttribute(PushMessage.class, "rel_uuid", type_uuid);
if (pushMessage == null) {
pushMessage = new PushMessage();
pushMessage.setCount(1);
} else { // 已经发过消息的情况下,只修改对应的内容.不新加数据.
if (SystemConstants.Read_flag_0.equals(pushMessage.getIsread())) { // 未读情况下,推送消息不在发送.
isSendPushMsg = false;
if (pushMessage.getCount() == null) { // 计数.
pushMessage.setCount(1);
} else {
pushMessage.setCount(pushMessage.getCount() + 1);
}
} else { //
pushMessage.setCount(1);
}
}
pushMessage.setGroup_uuid((String) obj.get("groupuuid"));
pushMessage.setRevice_useruuid((String) obj.get("create_useruuid"));
pushMessage.setType(SystemConstants.common_type_hudong);
pushMessage.setRel_uuid(type_uuid);
pushMessage.setTitle("互动(" + pushMessage.getCount() + ")");
pushMessage.setMessage(PxStringUtil.getSubString(msg, 128));
pushMessage.setCreate_time(TimeUtils.getCurrentTimestamp());
pushMessage.setIsread(SystemConstants.Read_flag_0);
this.nSimpleHibernateDao.save(pushMessage);
if (isSendPushMsg) { // 不重复发送消息
if ("1".equals((obj.get("usertype").toString()))) {
// 家长
this.pushMsgToAPPIservice.pushMsg_to_parent_app(
pushMessage.getRevice_useruuid(), pushMessage.getTitle(), msg);
} else {
// 老师
this.pushMsgToAPPIservice.pushMsg_to_teacher_app(
pushMessage.getRevice_useruuid(), pushMessage.getTitle(), msg);
}
}
}
/** 为Query添加distinct transformer. 预加载关联对象的HQL会引起主对象重复, 需要进行distinct处理. */
public Query distinct(Query query) {
query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return query;
}
public List<Arquivo> getArquivos(
Integer materia, Integer ano, Integer semestre, Integer professor, String turno)
throws IntranetException {
log.info("Executando DAO");
log.info("ANO: " + ano);
log.info("SEMESTRE: " + semestre);
log.info("MATERIA: " + materia);
log.info("Professor: " + professor);
log.info("Turno: " + turno);
if ((ano == null || ano == -1)
&& (semestre == null || semestre == -1)
&& (materia == null || materia == -1)
&& (professor == null || professor == -1)
&& (StringUtils.isNullOrEmpty(turno) || turno.equals("-1"))) {
log.info("Recuperando arquivos");
String hqlQuery =
"SELECT arquivo FROM Arquivo arquivo, IN(arquivo.disciplinaLetiva.disciplina.cursos) curso";
Query query = dao.getHibernateSession().createQuery(hqlQuery);
query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
List<Arquivo> listaArquivosComParam = query.list();
return listaArquivosComParam;
}
boolean first = true;
String hqlQuery =
"SELECT arquivo FROM Arquivo arquivo, IN(arquivo.disciplinaLetiva.disciplina.cursos) curso WHERE ";
if (ano != -1) {
if (first) {
hqlQuery = hqlQuery + "arquivo.disciplinaLetiva.ano = " + ano;
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.disciplinaLetiva.ano = " + ano;
}
}
if (semestre != -1) {
if (first) {
hqlQuery = hqlQuery + "arquivo.disciplinaLetiva.semestre = " + semestre;
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.disciplinaLetiva.semestre = " + semestre;
}
}
if (materia != -1) {
if (first) {
hqlQuery = hqlQuery + "arquivo.disciplinaLetiva.disciplina.id = " + materia;
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.disciplinaLetiva.disciplina.id = " + materia;
}
}
if (professor != -1) {
if (first) {
hqlQuery = hqlQuery + "arquivo.professor.id = " + professor;
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.professor.id = " + professor;
}
}
log.info("Iniciando filtro");
if (StringUtils.isNotNull(turno) && !turno.equals("-1")) {
log.info("Entrou em turno");
if (first) {
hqlQuery = hqlQuery + "arquivo.disciplinaLetiva.turno = '" + turno + "'";
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.disciplinaLetiva.turno = '" + turno + "'";
}
}
log.info("QUERY: " + hqlQuery);
Query query = dao.getHibernateSession().createQuery(hqlQuery);
query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
List<Arquivo> listaArquivosComParam = query.list();
return listaArquivosComParam;
}
@Override
public List<Arquivo> getArquivos(
Integer materia, Integer ano, Integer semestre, Integer professor) throws IntranetException {
log.info("Executando DAO");
log.info("ANO: " + ano);
log.info("SEMESTRE: " + semestre);
log.info("MATERIA: " + materia);
log.info("Professor: " + professor);
if ((ano == null || ano == -1)
&& (semestre == null || semestre == -1)
&& (materia == null || materia == -1)
&& (professor == null || professor == -1)) {
log.info("Recuperando arquivos");
String hqlQuery =
"SELECT arquivo FROM Arquivo arquivo, IN(arquivo.disciplinaLetiva.disciplina.cursos) curso";
Query query = dao.getHibernateSession().createQuery(hqlQuery);
query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
List<Arquivo> listaArquivosComParam = query.list();
return listaArquivosComParam;
}
boolean first = true;
String hqlQuery =
"SELECT arquivo FROM Arquivo arquivo, IN(arquivo.disciplinaLetiva.disciplina.cursos) curso WHERE ";
if (ano != -1) {
if (first) {
hqlQuery = hqlQuery + "arquivo.disciplinaLetiva.ano = " + ano;
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.disciplinaLetiva.ano = " + ano;
}
}
if (semestre != -1) {
if (first) {
hqlQuery = hqlQuery + "arquivo.disciplinaLetiva.semestre = " + semestre;
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.disciplinaLetiva.semestre = " + semestre;
}
}
if (materia != -1) {
if (first) {
hqlQuery = hqlQuery + "arquivo.disciplinaLetiva.disciplina.id = " + materia;
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.disciplinaLetiva.disciplina.id = " + materia;
}
}
if (professor != -1) {
if (first) {
hqlQuery = hqlQuery + "arquivo.professor.id = " + professor;
first = false;
} else {
hqlQuery = hqlQuery + " AND arquivo.professor.id = " + professor;
}
}
Query query = dao.getHibernateSession().createQuery(hqlQuery);
query.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
List<Arquivo> listaArquivosComParam = query.list();
return listaArquivosComParam;
}