cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dao/hibernate/common/DefinedTermDaoImpl.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.persistence.dao.hibernate.common;
  11
  12 import java.net.URI;
  13 import java.util.ArrayList;
  14 import java.util.Collection;
  15 import java.util.Enumeration;
  16 import java.util.List;
  17 import java.util.Locale;
  18 import java.util.Set;
  19 import java.util.UUID;
  20
  21 import org.apache.commons.lang.StringUtils;
  22 import org.apache.log4j.Logger;
  23 import org.hibernate.Criteria;
  24 import org.hibernate.Query;
  25 import org.hibernate.Session;
  26 import org.hibernate.criterion.Criterion;
  27 import org.hibernate.criterion.Projections;
  28 import org.hibernate.criterion.Restrictions;
  29 import org.hibernate.envers.query.AuditEntity;
  30 import org.hibernate.envers.query.AuditQuery;
  31 import org.springframework.stereotype.Repository;
  32
  33 import eu.etaxonomy.cdm.model.common.AnnotationType;
  34 import eu.etaxonomy.cdm.model.common.CdmBase;
  35 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  36 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  37 import eu.etaxonomy.cdm.model.common.ExtensionType;
  38 import eu.etaxonomy.cdm.model.common.Language;
  39 import eu.etaxonomy.cdm.model.common.MarkerType;
  40 import eu.etaxonomy.cdm.model.common.TermType;
  41 import eu.etaxonomy.cdm.model.description.MeasurementUnit;
  42 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
  43 import eu.etaxonomy.cdm.model.description.State;
  44 import eu.etaxonomy.cdm.model.description.StatisticalMeasure;
  45 import eu.etaxonomy.cdm.model.description.TextFormat;
  46 import eu.etaxonomy.cdm.model.location.Country;
  47 import eu.etaxonomy.cdm.model.location.NamedArea;
  48 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  49 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  50 import eu.etaxonomy.cdm.model.location.ReferenceSystem;
  51 import eu.etaxonomy.cdm.model.media.Media;
  52 import eu.etaxonomy.cdm.model.media.RightsType;
  53 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  54 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  55 import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
  56 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  57 import eu.etaxonomy.cdm.model.name.Rank;
  58 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  59 import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;
  60 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
  61 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  62 import eu.etaxonomy.cdm.model.view.AuditEvent;
  63 import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
  64 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  65 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  66
  67 /**
  68  * @author a.kohlbecker
  69  * @created 29.05.2008
  70  * @version 1.0
  71  */
  72 @Repository
  73 public class DefinedTermDaoImpl extends IdentifiableDaoBase<DefinedTermBase> implements IDefinedTermDao{
  74         private static final Logger logger = Logger.getLogger(DefinedTermDaoImpl.class);
  75
  76         public DefinedTermDaoImpl() {
  77                 super(DefinedTermBase.class);
  78                 indexedClasses = new Class[25];
  79                 indexedClasses[0] = Rank.class;
  80                 indexedClasses[1] = AnnotationType.class;
  81                 indexedClasses[2] = ExtensionType.class;
  82                 indexedClasses[3] = Language.class;
  83                 indexedClasses[4] = MarkerType.class;
  84                 indexedClasses[5] = MeasurementUnit.class;
  85                 indexedClasses[6] = DefinedTerm.class;
  86                 indexedClasses[7] = PresenceAbsenceTerm.class;
  87                 indexedClasses[8] = State.class;
  88                 indexedClasses[9] = StatisticalMeasure.class;
  89                 indexedClasses[10] = TextFormat.class;
  90                 indexedClasses[11] = DerivationEventType.class;
  91                 indexedClasses[12] = NamedArea.class;
  92                 indexedClasses[13] = NamedAreaLevel.class;
  93                 indexedClasses[14] = NamedAreaType.class;
  94                 indexedClasses[15] = ReferenceSystem.class;
  95                 indexedClasses[16] = Country.class;
  96                 indexedClasses[17] = RightsType.class;
  97                 indexedClasses[18] = HybridRelationshipType.class;
  98                 indexedClasses[19] = NameRelationshipType.class;
  99                 indexedClasses[20] = NameTypeDesignationStatus.class;
 100                 indexedClasses[21] = NomenclaturalStatusType.class;
 101                 indexedClasses[22] = SpecimenTypeDesignationStatus.class;
 102                 indexedClasses[23] = SynonymRelationshipType.class;
 103                 indexedClasses[24] = TaxonRelationshipType.class;
 104         }
 105
 106         /**
 107          * Searches by Label
 108          * @see eu.etaxonomy.cdm.persistence.dao.common.ITitledDao#findByTitle(java.lang.String)
 109          */
 110         @Override
 111     public List<DefinedTermBase> findByTitle(String queryString) {
 112                 return findByTitle(queryString, null);
 113         }
 114
 115
 116         /**
 117          * Searches by Label
 118          * @see eu.etaxonomy.cdm.persistence.dao.common.ITitledDao#findByTitle(java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase)
 119          */
 120         @Override
 121     public List<DefinedTermBase> findByTitle(String queryString, CdmBase sessionObject) {
 122                 checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, CdmBase sessionObject)");
 123                 Session session = getSession();
 124                 if ( sessionObject != null ) {// FIXME is this needed?
 125                         session.update(sessionObject);
 126                 }
 127                 Query query = session.createQuery("select term from DefinedTermBase term join fetch term.representations representation where representation.label = :label");
 128                 query.setParameter("label", queryString);
 129                 return query.list();
 130
 131         }
 132
 133         @Override
 134     public List<DefinedTermBase> findByTitleAndClass(String queryString, Class<DefinedTermBase> clazz) {
 135                 checkNotInPriorView("DefinedTermDaoImpl.findByTitleAndClass(String queryString, Class<DefinedTermBase> clazz)");
 136                 Session session = getSession();
 137                 Criteria crit = session.createCriteria(clazz);
 138                 crit.add(Restrictions.ilike("persistentTitleCache", queryString));
 139                 List<DefinedTermBase> results = crit.list();
 140                 return results;
 141         }
 142
 143         @Override
 144     public List<DefinedTermBase> findByTitle(String queryString, MatchMode matchMode, int page, int pagesize, List<Criterion> criteria) {
 145                 //FIXME is query parametrised?
 146                 checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, ITitledDao.MATCH_MODE matchMode, int page, int pagesize, List<Criterion> criteria)");
 147                 Criteria crit = getSession().createCriteria(type);
 148                 crit.add(Restrictions.ilike("titleCache", matchMode.queryStringFrom(queryString)));
 149                 crit.setMaxResults(pagesize);
 150                 int firstItem = (page - 1) * pagesize + 1;
 151                 crit.setFirstResult(firstItem);
 152                 List<DefinedTermBase> results = crit.list();
 153                 return results;
 154         }
 155
 156
 157         @Override
 158     public Country getCountryByIso(String iso3166) {
 159                 // If iso639 = "" query returns non-unique result. We prevent this here:
 160                 if (StringUtils.isBlank(iso3166)) { return null; }
 161                 AuditEvent auditEvent = getAuditEventFromContext();
 162                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 163                   Query query = getSession().createQuery("from Country where iso3166_A2 = :isoCode");
 164                   query.setParameter("isoCode", iso3166);
 165                   return (Country) query.uniqueResult();
 166                 } else {
 167                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Country.class,auditEvent.getRevisionNumber());
 168                         query.add(AuditEntity.property("iso3166_A2").eq(iso3166));
 169                         return (Country) query.getSingleResult();
 170                 }
 171         }
 172
 173         @Override
 174     public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz ) {
 175                 return getDefinedTermByRepresentationText(text,clazz,null,null);
 176         }
 177
 178         @Override
 179     public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber) {
 180                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByRepresentationText(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber)");
 181
 182                 Criteria criteria = null;
 183                 if(clazz == null) {
 184                         criteria = getSession().createCriteria(type);
 185                 } else {
 186                         criteria = getSession().createCriteria(clazz);
 187                 }
 188
 189                 criteria.createAlias("representations", "r").add(Restrictions.like("r.text", text));
 190
 191                 if(pageSize != null) {
 192                         criteria.setMaxResults(pageSize);
 193                     if(pageNumber != null) {
 194                         criteria.setFirstResult(pageNumber * pageSize);
 195                     }
 196                 }
 197
 198                 return criteria.list();
 199         }
 200
 201         @Override
 202     public int countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz) {
 203             checkNotInPriorView("DefinedTermDaoImpl.countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz)");
 204                 Criteria criteria = null;
 205                 if(clazz == null) {
 206                         criteria = getSession().createCriteria(type);
 207                 } else {
 208                         criteria = getSession().createCriteria(clazz);
 209                 }
 210
 211                 criteria.createAlias("representations", "r").add(Restrictions.like("r.text", text));
 212
 213                 criteria.setProjection(Projections.rowCount());
 214
 215         return ((Number)criteria.uniqueResult()).intValue();
 216         }
 217
 218         @Override
 219         public <T extends DefinedTermBase> List<T> getDefinedTermByIdInVocabulary(String label, UUID vocUuid, Class<T> clazz, Integer pageSize, Integer pageNumber) {
 220                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByIdInVocabulary(String label, UUID vocUuid, Class<T> clazz, Integer pageSize, Integer pageNumber)");
 221
 222                 Criteria criteria = null;
 223                 if(clazz == null) {
 224                         criteria = getSession().createCriteria(type);
 225                 } else {
 226                         criteria = getSession().createCriteria(clazz);
 227                 }
 228
 229                 criteria.createAlias("vocabulary", "voc").add(Restrictions.like("voc.uuid", vocUuid))
 230                         .add(Restrictions.like("idInVocabulary", label, org.hibernate.criterion.MatchMode.EXACT));
 231
 232                 if(pageSize != null) {
 233                         criteria.setMaxResults(pageSize);
 234                     if(pageNumber != null) {
 235                         criteria.setFirstResult(pageNumber * pageSize);
 236                     }
 237                 }
 238
 239                 List<T> result = criteria.list();
 240                 return result;
 241         }
 242
 243         @Override
 244         public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationAbbrev(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber) {
 245                 checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByRepresentationAbbrev(String abbrev, Class<T> clazz, Integer pageSize,Integer  pageNumber)");
 246
 247                 Criteria criteria = null;
 248                 if(clazz == null) {
 249                         criteria = getSession().createCriteria(type);
 250                 } else {
 251                         criteria = getSession().createCriteria(clazz);
 252                 }
 253
 254                 criteria.createAlias("representations", "r").add(Restrictions.like("r.abbreviatedLabel", text));
 255
 256                 if(pageSize != null) {
 257                         criteria.setMaxResults(pageSize);
 258                     if(pageNumber != null) {
 259                         criteria.setFirstResult(pageNumber * pageSize);
 260                     }
 261                 }
 262
 263                 return criteria.list();
 264         }
 265
 266         @Override
 267         public int countDefinedTermByRepresentationAbbrev(String text, Class<? extends DefinedTermBase> clazz) {
 268             checkNotInPriorView("DefinedTermDaoImpl.countDefinedTermByRepresentationAbbrev(String abbrev, Class<? extends DefinedTermBase> clazz)");
 269                 Criteria criteria = null;
 270                 if(clazz == null) {
 271                         criteria = getSession().createCriteria(type);
 272                 } else {
 273                         criteria = getSession().createCriteria(clazz);
 274                 }
 275
 276                 criteria.createAlias("representations", "r").add(Restrictions.like("r.abbreviatedLabel", text));
 277
 278
 279                 criteria.setProjection(Projections.rowCount());
 280
 281         return ((Number)criteria.uniqueResult()).intValue();
 282         }
 283
 284         @Override
 285     public Language getLanguageByIso(String iso639) {
 286                 if (iso639.length() < 2 || iso639.length() > 3) {
 287                         logger.warn("Invalid length " + iso639.length() + " of ISO code. Length must be 2 or 3.");
 288                         return null;
 289                 }
 290                 boolean isIso639_1 = iso639.length() == 2;
 291
 292                 String queryStr;
 293                 if (isIso639_1){
 294                         queryStr = "from Language where iso639_1 = :isoCode";
 295                 }else{
 296                         queryStr = "from Language where idInVocabulary = :isoCode and vocabulary.uuid = :vocUuid";
 297                 }
 298                 AuditEvent auditEvent = getAuditEventFromContext();
 299                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 300                     Query query = getSession().createQuery(queryStr);
 301                     query.setParameter("isoCode", iso639);
 302                     if (! isIso639_1){
 303                         query.setParameter("vocUuid", Language.uuidLanguageVocabulary);
 304                         }
 305                     return (Language) query.uniqueResult();
 306                 } else {
 307                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Language.class,auditEvent.getRevisionNumber());
 308                         if (isIso639_1){
 309                                 query.add(AuditEntity.property("iso639_1").eq(iso639));
 310                         }else{
 311                                 query.add(AuditEntity.property("iso639_2").eq(iso639));
 312                                 query.add(AuditEntity.property("vocabulary.uuid").eq(Language.uuidLanguageVocabulary));
 313                         }
 314
 315                         return (Language)query.getSingleResult();
 316                 }
 317         }
 318
 319         /**
 320          *  FIXME this will result in a query per language - could you, given that iso codes
 321          *  are unique, use from Language where iso639_1 in (:isoCode) or iso639_2 in (:isoCode)
 322          */
 323         @Override
 324     public List<Language> getLanguagesByIso(List<String> iso639List) {
 325                 List<Language> languages = new ArrayList<Language>(iso639List.size());
 326                 for (String iso639 : iso639List) {
 327                         languages.add(getLanguageByIso(iso639));
 328                 }
 329                 return languages;
 330         }
 331
 332         @Override
 333     public List<Language> getLanguagesByLocale(Enumeration<Locale> locales) {
 334                 List<Language> languages = new ArrayList<Language>();
 335                 while(locales.hasMoreElements()) {
 336                         Locale locale = locales.nextElement();
 337                         languages.add(getLanguageByIso(locale.getLanguage()));
 338                 }
 339                 return languages;
 340         }
 341
 342         @Override
 343     public int count(NamedAreaLevel level, NamedAreaType type) {
 344                 AuditEvent auditEvent = getAuditEventFromContext();
 345                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 346                     Criteria criteria = getSession().createCriteria(NamedArea.class);
 347
 348                     if(level != null) {
 349                             criteria.add(Restrictions.eq("level",level));
 350                     }
 351
 352                     if(type != null) {
 353                             criteria.add(Restrictions.eq("type", type));
 354                     }
 355
 356                     criteria.setProjection(Projections.rowCount());
 357
 358                 return ((Number)criteria.uniqueResult()).intValue();
 359                 } else {
 360                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,auditEvent.getRevisionNumber());
 361
 362                         if(level != null) {
 363                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 364                     }
 365
 366                     if(type != null) {
 367                         query.add(AuditEntity.relatedId("type").eq(type.getId()));
 368                     }
 369                     query.addProjection(AuditEntity.id().count("id"));
 370                     return ((Long)query.getSingleResult()).intValue();
 371                 }
 372         }
 373
 374         @Override
 375     public int countMedia(DefinedTermBase definedTerm) {
 376                 checkNotInPriorView("DefinedTermDaoImpl.countMedia(DefinedTermBase definedTerm)");
 377                 Query query = getSession().createQuery("select count(media) from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");
 378             query.setParameter("definedTerm", definedTerm);
 379
 380                 return ((Long)query.uniqueResult()).intValue();
 381         }
 382
 383         @Override
 384     public List<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize,  Integer pageNumber) {
 385                 checkNotInPriorView("DefinedTermDaoImpl.getMedia(DefinedTermBase definedTerm, Integer pageSize, Integer pageNumber)");
 386                 Query query = getSession().createQuery("select media from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");
 387                 query.setParameter("definedTerm", definedTerm);
 388
 389                 if(pageSize != null) {
 390                         query.setMaxResults(pageSize);
 391                     if(pageNumber != null) {
 392                         query.setFirstResult(pageNumber * pageSize);
 393                     }
 394                 }
 395
 396                 return query.list();
 397         }
 398
 399         /* (non-Javadoc)
 400          * @see eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao#list(eu.etaxonomy.cdm.model.location.NamedAreaLevel, eu.etaxonomy.cdm.model.location.NamedAreaType, java.lang.Integer, java.lang.Integer)
 401          */
 402         @Override
 403     public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber) {
 404                 AuditEvent auditEvent = getAuditEventFromContext();
 405                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 406             Criteria criteria = getSession().createCriteria(NamedArea.class);
 407
 408                     if(level != null) {
 409                             criteria.add(Restrictions.eq("level",level));
 410                     }
 411
 412                     if(type != null) {
 413                             criteria.add(Restrictions.eq("type", type));
 414                     }
 415
 416                     if(pageSize != null) {
 417                             criteria.setMaxResults(pageSize);
 418                         if(pageNumber != null) {
 419                             criteria.setFirstResult(pageNumber * pageSize);
 420                         }
 421                     }
 422
 423                     return criteria.list();
 424                 } else {
 425             AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,auditEvent.getRevisionNumber());
 426
 427                         if(level != null) {
 428                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 429                     }
 430
 431                     if(type != null) {
 432                         query.add(AuditEntity.relatedId("type").eq(type.getId()));
 433                     }
 434
 435                     return query.getResultList();
 436                 }
 437         }
 438
 439         /* (non-Javadoc)
 440          * @see eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao#list(eu.etaxonomy.cdm.model.location.NamedAreaLevel, eu.etaxonomy.cdm.model.location.NamedAreaType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 441          */
 442         @Override
 443     public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber,
 444                         List<OrderHint> orderHints, List<String> propertyPaths) {
 445
 446                 List<NamedArea> result;
 447
 448                 AuditEvent auditEvent = getAuditEventFromContext();
 449                 if (auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 450                         Criteria criteria = getSession().createCriteria(NamedArea.class);
 451
 452                         if (level != null) {
 453                                 criteria.add(Restrictions.eq("level", level));
 454                         }
 455                         if (type != null) {
 456                                 criteria.add(Restrictions.eq("type", type));
 457                         }
 458                         if(orderHints != null){
 459                                 addOrder(criteria,orderHints);
 460                         }
 461                         if (pageSize != null) {
 462                                 criteria.setMaxResults(pageSize);
 463                                 if (pageNumber != null) {
 464                                         criteria.setFirstResult(pageNumber * pageSize);
 465                                 }
 466                         }
 467
 468                         result = criteria.list();
 469                 } else {
 470                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,
 471                                 auditEvent.getRevisionNumber());
 472                         if (level != null) {
 473                                 query.add(AuditEntity.relatedId("level").eq(level.getId()));
 474                         }
 475                         if (type != null) {
 476                                 query.add(AuditEntity.relatedId("type").eq(type.getId()));
 477                         }
 478                         result =  query.getResultList();
 479                 }
 480
 481                 defaultBeanInitializer.initializeAll(result, propertyPaths);
 482
 483                 return result;
 484         }
 485
 486
 487         @Override
 488     public <T extends DefinedTermBase> int countGeneralizationOf(T kindOf) {
 489                 AuditEvent auditEvent = getAuditEventFromContext();
 490                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 491                     Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.kindOf = :kindOf");
 492                     query.setParameter("kindOf", kindOf);
 493                     return ((Long)query.uniqueResult()).intValue();
 494                 } else {
 495             AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 496                         query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));
 497                     query.addProjection(AuditEntity.id().count("id"));
 498                     return ((Long)query.getSingleResult()).intValue();
 499                 }
 500         }
 501
 502         @Override
 503     public <T extends DefinedTermBase> int countIncludes(Collection<T> partOf) {
 504                 if (partOf == null || partOf.isEmpty()){
 505                         return 0;
 506                 }
 507                 AuditEvent auditEvent = getAuditEventFromContext();
 508                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 509                 Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.partOf in (:partOf)");
 510                 query.setParameterList("partOf", partOf);
 511                     return ((Long)query.uniqueResult()).intValue();
 512                 } else {
 513                         Integer count = 0;
 514                         for(T t : partOf) {
 515                                 AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 516                                 query.add(AuditEntity.relatedId("partOf").eq(t.getId()));
 517                             query.addProjection(AuditEntity.id().count("id"));
 518                             count += ((Long)query.getSingleResult()).intValue();
 519                         }
 520                         return count;
 521                 }
 522         }
 523
 524         @Override
 525     public <T extends DefinedTermBase> List<T> getGeneralizationOf(T kindOf, Integer pageSize, Integer pageNumber) {
 526                 AuditEvent auditEvent = getAuditEventFromContext();
 527                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 528                     Query query = getSession().createQuery("select term from DefinedTermBase term where term.kindOf = :kindOf");
 529                     query.setParameter("kindOf", kindOf);
 530
 531                     if(pageSize != null) {
 532                             query.setMaxResults(pageSize);
 533                         if(pageNumber != null) {
 534                             query.setFirstResult(pageNumber * pageSize);
 535                         }
 536                     }
 537
 538                 return query.list();
 539                 } else {
 540                          AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 541                          query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));
 542
 543                          if(pageSize != null) {
 544                             query.setMaxResults(pageSize);
 545                              if(pageNumber != null) {
 546                                     query.setFirstResult(pageNumber * pageSize);
 547                              }
 548                          }
 549
 550                          return query.getResultList();
 551                 }
 552         }
 553
 554         @Override
 555     public <T extends DefinedTermBase> List<T> getIncludes(Collection<T> partOf,        Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 556                 if (partOf == null || partOf.isEmpty()){
 557                         return new ArrayList<T>();
 558                 }
 559                 AuditEvent auditEvent = getAuditEventFromContext();
 560                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 561                 Query query = getSession().createQuery("select term from DefinedTermBase term where term.partOf in (:partOf)");
 562                 query.setParameterList("partOf", partOf);
 563
 564                     if(pageSize != null) {
 565                             query.setMaxResults(pageSize);
 566                         if(pageNumber != null) {
 567                             query.setFirstResult(pageNumber * pageSize);
 568                         }
 569                     }
 570
 571                     List<T> results = query.list();
 572                     defaultBeanInitializer.initializeAll(results, propertyPaths);
 573                     return results;
 574                 } else {
 575                         List<T> result = new ArrayList<T>();
 576                         for(T t : partOf) {
 577                                 AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 578                                 query.add(AuditEntity.relatedId("partOf").eq(t.getId()));
 579                                 if(pageSize != null) {
 580                                     query.setMaxResults(pageSize);
 581                                 if(pageNumber != null) {
 582                                     query.setFirstResult(pageNumber * pageSize);
 583                                 }
 584                             }
 585
 586                             result.addAll(query.getResultList());
 587                         }
 588                         defaultBeanInitializer.initializeAll(result, propertyPaths);
 589                         return result;
 590                 }
 591         }
 592
 593         @Override
 594     public <T extends DefinedTermBase> int countPartOf(Set<T> definedTerms) {
 595                 checkNotInPriorView("DefinedTermDaoImpl.countPartOf(Set<T> definedTerms)");
 596                 Query query = getSession().createQuery("select count(distinct definedTerm) from DefinedTermBase definedTerm join definedTerm.includes included where included in (:definedTerms)");
 597                 query.setParameterList("definedTerms", definedTerms);
 598                 return ((Long)query.uniqueResult()).intValue();
 599         }
 600
 601         @Override
 602     public <T extends DefinedTermBase> List<T> getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 603                 checkNotInPriorView("DefinedTermDaoImpl.getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber)");
 604                 Query query = getSession().createQuery("select distinct definedTerm from DefinedTermBase definedTerm join definedTerm.includes included where included in (:definedTerms)");
 605                 query.setParameterList("definedTerms", definedTerms);
 606
 607                 if(pageSize != null) {
 608                         query.setMaxResults(pageSize);
 609                     if(pageNumber != null) {
 610                         query.setFirstResult(pageNumber * pageSize);
 611                     }
 612                 }
 613                 List<T> r = query.list();
 614                 /**
 615                  * For some weird reason, hibernate returns proxies (extending the superclass), not the actual class on this,
 616                  * despite querying the damn database and returning the discriminator along with the rest of the object properties!
 617                  *
 618                  * Probably a bug in hibernate, but we'll manually deproxy for now since the objects are initialized anyway, the
 619                  * performance implications are small (we're swapping one array of references for another, not hitting the db or
 620                  * cache).
 621                  */
 622                 List<T> results = new ArrayList<T>();
 623                 if(!definedTerms.isEmpty()) {
 624                     Class<T> type = (Class<T>)definedTerms.iterator().next().getClass();
 625                     for(T t : r) {
 626                             results.add(CdmBase.deproxy(t, type));
 627                     }
 628                     defaultBeanInitializer.initializeAll(results, propertyPaths);
 629                 }
 630                 return results;
 631         }
 632
 633         @Override
 634     public DefinedTermBase findByUri(URI uri) {
 635                 AuditEvent auditEvent = getAuditEventFromContext();
 636                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 637                     Query query = getSession().createQuery("select term from DefinedTermBase term where term.uri = :uri");
 638                     query.setParameter("uri", uri);
 639                     return (DefinedTermBase)query.uniqueResult();
 640                 } else {
 641                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(DefinedTermBase.class,auditEvent.getRevisionNumber());
 642                         query.add(AuditEntity.property("uri").eq(uri));
 643                     return (DefinedTermBase)query.getSingleResult();
 644                 }
 645         }
 646
 647         /* (non-Javadoc)
 648          * @see eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao#listByTermType(eu.etaxonomy.cdm.model.common.TermType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 649          */
 650         @Override
 651         public List<DefinedTermBase<?>> listByTermType(TermType termType, Integer limit, Integer start,
 652                 List<OrderHint> orderHints, List<String> propertyPaths) {
 653             Query query = getSession().createQuery("select term from DefinedTermBase term where term.termType = :termType");
 654             query.setParameter("termType", termType);
 655
 656             List result = query.list();
 657
 658             defaultBeanInitializer.initializeAll(result, propertyPaths);
 659
 660         return result;
 661         }
 662
 663         @Override
 664     public <TERM extends DefinedTermBase> List<TERM> listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 665 //              checkNotInPriorView("DefinedTermDaoImpl.listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths)");
 666
 667                 Query query = getSession().createQuery("from " + clazz.getSimpleName());
 668             //query.setParameter("DTYPE", );
 669
 670             List<TERM> result = query.list();
 671
 672             defaultBeanInitializer.initializeAll(result, propertyPaths);
 673
 674             return result;
 675         }
 676 }