cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dao/hibernate/name/TaxonNameDaoHibernateImpl.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.name;
  11
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import java.util.Set;
  15 import java.util.UUID;
  16
  17 import org.apache.log4j.Logger;
  18 import org.hibernate.Criteria;
  19 import org.hibernate.Query;
  20 import org.hibernate.Session;
  21 import org.hibernate.criterion.Criterion;
  22 import org.hibernate.criterion.Order;
  23 import org.hibernate.criterion.Projections;
  24 import org.hibernate.criterion.Restrictions;
  25 import org.hibernate.envers.query.AuditEntity;
  26 import org.hibernate.envers.query.AuditQuery;
  27 import org.springframework.beans.factory.annotation.Autowired;
  28 import org.springframework.beans.factory.annotation.Qualifier;
  29 import org.springframework.stereotype.Repository;
  30
  31 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  32 import eu.etaxonomy.cdm.model.common.CdmBase;
  33 import eu.etaxonomy.cdm.model.common.RelationshipBase;
  34 import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
  35 import eu.etaxonomy.cdm.model.name.BacterialName;
  36 import eu.etaxonomy.cdm.model.name.BotanicalName;
  37 import eu.etaxonomy.cdm.model.name.CultivarPlantName;
  38 import eu.etaxonomy.cdm.model.name.HybridRelationship;
  39 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  40 import eu.etaxonomy.cdm.model.name.NameRelationship;
  41 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  42 import eu.etaxonomy.cdm.model.name.NonViralName;
  43 import eu.etaxonomy.cdm.model.name.Rank;
  44 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  45 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  46 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  47 import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;
  48 import eu.etaxonomy.cdm.model.name.ViralName;
  49 import eu.etaxonomy.cdm.model.name.ZoologicalName;
  50 import eu.etaxonomy.cdm.model.taxon.Taxon;
  51 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  52 import eu.etaxonomy.cdm.model.view.AuditEvent;
  53 import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;
  54 import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
  55 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;
  56 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  57 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  58
  59 /**
  60  * @author a.mueller
  61  *
  62  */
  63 @Repository
  64 @Qualifier("taxonNameDaoHibernateImpl")
  65 public class TaxonNameDaoHibernateImpl
  66 extends IdentifiableDaoBase<TaxonNameBase> implements ITaxonNameDao {
  67
  68         @SuppressWarnings("unused")
  69         private static final Logger logger = Logger.getLogger(TaxonNameDaoHibernateImpl.class);
  70
  71         @Autowired
  72         private ITaxonDao taxonDao;
  73
  74         public TaxonNameDaoHibernateImpl() {
  75                 super(TaxonNameBase.class);
  76                 indexedClasses = new Class[6];
  77                 indexedClasses[0] = BacterialName.class;
  78                 indexedClasses[1] = BotanicalName.class;
  79                 indexedClasses[2] = CultivarPlantName.class;
  80                 indexedClasses[3] = NonViralName.class;
  81                 indexedClasses[4] = ViralName.class;
  82                 indexedClasses[5] = ZoologicalName.class;
  83         }
  84
  85         public int countHybridNames(NonViralName name, HybridRelationshipType type) {
  86                 AuditEvent auditEvent = getAuditEventFromContext();
  87                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
  88                         Query query = null;
  89                         if(type == null) {
  90                                 query = getSession().createQuery("select count(relation) from HybridRelationship relation where relation.relatedFrom = :name");
  91                         } else {
  92                                 query = getSession().createQuery("select count(relation) from HybridRelationship relation where relation.relatedFrom = :name and relation.type = :type");
  93                                 query.setParameter("type", type);
  94                         }
  95                         query.setParameter("name",name);
  96                         return ((Long)query.uniqueResult()).intValue();
  97                 } else {
  98                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(HybridRelationship.class,auditEvent.getRevisionNumber());
  99                         query.add(AuditEntity.relatedId("relatedFrom").eq(name.getId()));
 100                         query.addProjection(AuditEntity.id().count("id"));
 101
 102                         if(type != null) {
 103                                 query.add(AuditEntity.relatedId("type").eq(type.getId()));
 104                         }
 105
 106                         return ((Long)query.getSingleResult()).intValue();
 107                 }
 108         }
 109
 110         public int countNames(String queryString) {
 111                 checkNotInPriorView("TaxonNameDaoHibernateImpl.countNames(String queryString)");
 112         Criteria criteria = getSession().createCriteria(TaxonNameBase.class);
 113
 114                 if (queryString != null) {
 115                         criteria.add(Restrictions.ilike("nameCache", queryString));
 116                 }
 117                 criteria.setProjection(Projections.projectionList().add(Projections.rowCount()));
 118
 119                 return (Integer)criteria.uniqueResult();
 120         }
 121
 122         public int countNames(String queryString, MatchMode matchMode, List<Criterion> criteria) {
 123
 124                 Criteria crit = getSession().createCriteria(type);
 125                 if (matchMode == MatchMode.EXACT) {
 126                         crit.add(Restrictions.eq("nameCache", matchMode.queryStringFrom(queryString)));
 127                 } else {
 128                         crit.add(Restrictions.ilike("nameCache", matchMode.queryStringFrom(queryString)));
 129                 }
 130                 if(criteria != null) {
 131                         for (Criterion criterion : criteria) {
 132                                 crit.add(criterion);
 133                         }
 134                 }
 135
 136                 crit.setProjection(Projections.projectionList().add(Projections.rowCount()));
 137                 return (Integer)crit.uniqueResult();
 138         }
 139
 140         public int countNames(String genusOrUninomial, String infraGenericEpithet,      String specificEpithet, String infraSpecificEpithet, Rank rank) {
 141                 AuditEvent auditEvent = getAuditEventFromContext();
 142                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 143                         Criteria criteria = getSession().createCriteria(TaxonNameBase.class);
 144
 145                         /**
 146                          * Given HHH-2951 - "Restrictions.eq when passed null, should create a NullRestriction"
 147                          * We need to convert nulls to NullRestrictions for now
 148                          */
 149                         if(genusOrUninomial != null) {
 150                                 criteria.add(Restrictions.eq("genusOrUninomial",genusOrUninomial));
 151                         } else {
 152                                 criteria.add(Restrictions.isNull("genusOrUninomial"));
 153                         }
 154
 155                         if(infraGenericEpithet != null) {
 156                                 criteria.add(Restrictions.eq("infraGenericEpithet", infraGenericEpithet));
 157                         } else {
 158                                 criteria.add(Restrictions.isNull("infraGenericEpithet"));
 159                         }
 160
 161                         if(specificEpithet != null) {
 162                                 criteria.add(Restrictions.eq("specificEpithet", specificEpithet));
 163                         } else {
 164                                 criteria.add(Restrictions.isNull("specificEpithet"));
 165                         }
 166
 167                         if(infraSpecificEpithet != null) {
 168                                 criteria.add(Restrictions.eq("infraSpecificEpithet",infraSpecificEpithet));
 169                         } else {
 170                                 criteria.add(Restrictions.isNull("infraSpecificEpithet"));
 171                         }
 172
 173                         if(rank != null) {
 174                                 criteria.add(Restrictions.eq("rank", rank));
 175                         }
 176
 177                         criteria.setProjection(Projections.rowCount());
 178                         return (Integer)criteria.uniqueResult();
 179                 } else {
 180                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(TaxonNameBase.class,auditEvent.getRevisionNumber());
 181
 182                         if(genusOrUninomial != null) {
 183                                 query.add(AuditEntity.property("genusOrUninomial").eq(genusOrUninomial));
 184                         } else {
 185                                 query.add(AuditEntity.property("genusOrUninomial").isNull());
 186                         }
 187
 188                         if(infraGenericEpithet != null) {
 189                                 query.add(AuditEntity.property("infraGenericEpithet").eq(infraGenericEpithet));
 190                         } else {
 191                                 query.add(AuditEntity.property("infraGenericEpithet").isNull());
 192                         }
 193
 194                         if(specificEpithet != null) {
 195                                 query.add(AuditEntity.property("specificEpithet").eq(specificEpithet));
 196                         } else {
 197                                 query.add(AuditEntity.property("specificEpithet").isNull());
 198                         }
 199
 200                         if(infraSpecificEpithet != null) {
 201                                 query.add(AuditEntity.property("infraSpecificEpithet").eq(infraSpecificEpithet));
 202                         } else {
 203                                 query.add(AuditEntity.property("infraSpecificEpithet").isNull());
 204                         }
 205
 206                         if(rank != null) {
 207                                 query.add(AuditEntity.relatedId("rank").eq(rank.getId()));
 208                         }
 209
 210                         query.addProjection(AuditEntity.id().count("id"));
 211                         return ((Long)query.getSingleResult()).intValue();
 212                 }
 213         }
 214
 215         public int countNameRelationships(TaxonNameBase name, NameRelationship.Direction direction, NameRelationshipType type) {
 216
 217                 AuditEvent auditEvent = getAuditEventFromContext();
 218                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 219                         Query query = null;
 220                         if(type == null) {
 221                                 query = getSession().createQuery("select count(relation) from NameRelationship relation where relation." + direction +" = :name");
 222                         } else {
 223                                 query = getSession().createQuery("select count(relation) from NameRelationship relation where relation." + direction +" = :name and relation.type = :type");
 224                                 query.setParameter("type", type);
 225                         }
 226                         query.setParameter("name",name);
 227                         return ((Long)query.uniqueResult()).intValue();
 228                 } else {
 229                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NameRelationship.class,auditEvent.getRevisionNumber());
 230                         query.add(AuditEntity.relatedId(direction.toString()).eq(name.getId()));
 231                         query.addProjection(AuditEntity.id().count("id"));
 232
 233                         if(type != null) {
 234                                 query.add(AuditEntity.relatedId("type").eq(type.getId()));
 235                         }
 236
 237                         return ((Long)query.getSingleResult()).intValue();
 238                 }
 239         }
 240
 241         public int countTypeDesignations(TaxonNameBase name, SpecimenTypeDesignationStatus status) {
 242                 checkNotInPriorView("countTypeDesignations(TaxonNameBase name, SpecimenTypeDesignationStatus status)");
 243                 Query query = null;
 244                 if(status == null) {
 245                         query = getSession().createQuery("select count(designation) from TypeDesignationBase designation join designation.typifiedNames name where name = :name");
 246                 } else {
 247                         query = getSession().createQuery("select count(designation) from TypeDesignationBase designation join designation.typifiedNames name where name = :name and designation.typeStatus = :status");
 248                         query.setParameter("status", status);
 249                 }
 250                 query.setParameter("name",name);
 251                 return ((Long)query.uniqueResult()).intValue();
 252         }
 253
 254         public List<HybridRelationship> getHybridNames(NonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 255                 AuditEvent auditEvent = getAuditEventFromContext();
 256                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 257                         Criteria criteria = getSession().createCriteria(HybridRelationship.class);
 258                         criteria.add(Restrictions.eq("relatedFrom", name));
 259                         if(type != null) {
 260                                 criteria.add(Restrictions.eq("type", type));
 261                         }
 262
 263                         if(pageSize != null) {
 264                                 criteria.setMaxResults(pageSize);
 265                                 if(pageNumber != null) {
 266                                         criteria.setFirstResult(pageNumber * pageSize);
 267                                 } else {
 268                                         criteria.setFirstResult(0);
 269                                 }
 270                         }
 271
 272                         addOrder(criteria, orderHints);
 273
 274                         List<HybridRelationship> results = (List<HybridRelationship>)criteria.list();
 275                         defaultBeanInitializer.initializeAll(results, propertyPaths);
 276                         return results;
 277                 } else {
 278                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(HybridRelationship.class,auditEvent.getRevisionNumber());
 279                         query.add(AuditEntity.relatedId("relatedFrom").eq(name.getId()));
 280
 281                         if(type != null) {
 282                                 query.add(AuditEntity.relatedId("type").eq(type.getId()));
 283                         }
 284
 285                         if(pageSize != null) {
 286                                 query.setMaxResults(pageSize);
 287                                 if(pageNumber != null) {
 288                                         query.setFirstResult(pageNumber * pageSize);
 289                                 } else {
 290                                         query.setFirstResult(0);
 291                                 }
 292                         }
 293
 294                         List<HybridRelationship> results =  (List<HybridRelationship>)query.getResultList();
 295                         defaultBeanInitializer.initializeAll(results, propertyPaths);
 296                         return results;
 297                 }
 298         }
 299
 300         public List<NameRelationship> getNameRelationships(TaxonNameBase name, NameRelationship.Direction direction,
 301                         NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,
 302                         List<String> propertyPaths) {
 303
 304                 AuditEvent auditEvent = getAuditEventFromContext();
 305                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 306                         Criteria criteria = getSession().createCriteria(NameRelationship.class);
 307                         criteria.add(Restrictions.eq(direction.toString(), name));
 308                         if(type != null) {
 309                                 criteria.add(Restrictions.eq("type", type));
 310                         }
 311
 312                         if(pageSize != null) {
 313                                 criteria.setMaxResults(pageSize);
 314                                 if(pageNumber != null) {
 315                                         criteria.setFirstResult(pageNumber * pageSize);
 316                                 } else {
 317                                         criteria.setFirstResult(0);
 318                                 }
 319                         }
 320                         addOrder(criteria, orderHints);
 321
 322                         List<NameRelationship> results = (List<NameRelationship>)criteria.list();
 323                         defaultBeanInitializer.initializeAll(results, propertyPaths);
 324                         return results;
 325                 } else {
 326                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NameRelationship.class,auditEvent.getRevisionNumber());
 327                         query.add(AuditEntity.relatedId(direction.toString()).eq(name.getId()));
 328
 329                         if(type != null) {
 330                                 query.add(AuditEntity.relatedId("type").eq(type.getId()));
 331                         }
 332
 333                         if(pageSize != null) {
 334                                 query.setMaxResults(pageSize);
 335                                 if(pageNumber != null) {
 336                                         query.setFirstResult(pageNumber * pageSize);
 337                                 } else {
 338                                         query.setFirstResult(0);
 339                                 }
 340                         }
 341
 342                         List<NameRelationship> results = (List<NameRelationship>)query.getResultList();
 343                         defaultBeanInitializer.initializeAll(results, propertyPaths);
 344                         return results;
 345                 }
 346         }
 347
 348         public List<TypeDesignationBase> getTypeDesignations(TaxonNameBase name, TypeDesignationStatusBase status, Integer pageSize, Integer pageNumber,        List<String> propertyPaths){
 349                 return getTypeDesignations(name, null, status, pageSize, pageNumber, propertyPaths);
 350         }
 351
 352         public <T extends TypeDesignationBase> List<T> getTypeDesignations(TaxonNameBase name,
 353                                 Class<T> type,
 354                                 TypeDesignationStatusBase status, Integer pageSize, Integer pageNumber,
 355                                 List<String> propertyPaths){
 356                 checkNotInPriorView("getTypeDesignations(TaxonNameBase name,TypeDesignationStatusBase status, Integer pageSize, Integer pageNumber,     List<String> propertyPaths)");
 357                 Query query = null;
 358                 String queryString = "select designation from TypeDesignationBase designation join designation.typifiedNames name where name = :name";
 359
 360                 if(status != null) {
 361                         queryString +=  " and designation.typeStatus = :status";
 362                 }
 363                 if(type != null){
 364                         queryString +=  " and designation.class = :type";
 365                 }
 366
 367                 query = getSession().createQuery(queryString);
 368
 369                 if(status != null) {
 370                         query.setParameter("status", status);
 371                 }
 372                 if(type != null){
 373                         query.setParameter("type", type.getSimpleName());
 374                 }
 375
 376                 query.setParameter("name",name);
 377
 378                 if(pageSize != null) {
 379                         query.setMaxResults(pageSize);
 380                         if(pageNumber != null) {
 381                                 query.setFirstResult(pageNumber * pageSize);
 382                         } else {
 383                                 query.setFirstResult(0);
 384                         }
 385                 }
 386                 return defaultBeanInitializer.initializeAll((List<T>)query.list(), propertyPaths);
 387         }
 388
 389
 390         public List<TaxonNameBase<?,?>> searchNames(String queryString, MatchMode matchMode, Integer pageSize, Integer pageNumber) {
 391                 checkNotInPriorView("TaxonNameDaoHibernateImpl.searchNames(String queryString, Integer pageSize, Integer pageNumber)");
 392                 Criteria criteria = getSession().createCriteria(TaxonNameBase.class);
 393
 394                 if (queryString != null) {
 395                         criteria.add(Restrictions.ilike("nameCache", queryString));
 396                 }
 397                 if(pageSize != null) {
 398                 criteria.setMaxResults(pageSize);
 399                     if(pageNumber != null) {
 400                         criteria.setFirstResult(pageNumber * pageSize);
 401                     } else {
 402                         criteria.setFirstResult(0);
 403                     }
 404                 }
 405                 List<TaxonNameBase<?,?>> results = criteria.list();
 406                 return results;
 407         }
 408
 409
 410         public List<TaxonNameBase<?,?>> searchNames(String queryString, Integer pageSize, Integer pageNumber) {
 411                 return searchNames(queryString, MatchMode.BEGINNING, pageSize, pageNumber);
 412         }
 413
 414
 415         public List<TaxonNameBase> searchNames(String genusOrUninomial,String infraGenericEpithet, String specificEpithet,      String infraSpecificEpithet, Rank rank, Integer pageSize,Integer pageNumber, List<OrderHint> orderHints,
 416                         List<String> propertyPaths) {
 417                 AuditEvent auditEvent = getAuditEventFromContext();
 418                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 419                         Criteria criteria = getSession().createCriteria(TaxonNameBase.class);
 420
 421                         /**
 422                          * Given HHH-2951 - "Restrictions.eq when passed null, should create a NullRestriction"
 423                          * We need to convert nulls to NullRestrictions for now
 424                          */
 425                         if(genusOrUninomial != null) {
 426                                 criteria.add(Restrictions.eq("genusOrUninomial",genusOrUninomial));
 427                         } else {
 428                                 criteria.add(Restrictions.isNull("genusOrUninomial"));
 429                         }
 430
 431                         if(infraGenericEpithet != null) {
 432                                 criteria.add(Restrictions.eq("infraGenericEpithet", infraGenericEpithet));
 433                         } else {
 434                                 criteria.add(Restrictions.isNull("infraGenericEpithet"));
 435                         }
 436
 437                         if(specificEpithet != null) {
 438                                 criteria.add(Restrictions.eq("specificEpithet", specificEpithet));
 439                         } else {
 440                                 criteria.add(Restrictions.isNull("specificEpithet"));
 441                         }
 442
 443                         if(infraSpecificEpithet != null) {
 444                                 criteria.add(Restrictions.eq("infraSpecificEpithet",infraSpecificEpithet));
 445                         } else {
 446                                 criteria.add(Restrictions.isNull("infraSpecificEpithet"));
 447                         }
 448
 449                         if(rank != null) {
 450                             criteria.add(Restrictions.eq("rank", rank));
 451                         }
 452
 453                         if(pageSize != null) {
 454                                 criteria.setMaxResults(pageSize);
 455                                 if(pageNumber != null) {
 456                                         criteria.setFirstResult(pageNumber * pageSize);
 457                                 } else {
 458                                         criteria.setFirstResult(0);
 459                                 }
 460                         }
 461
 462                         addOrder(criteria, orderHints);
 463
 464                         List<TaxonNameBase> results = (List<TaxonNameBase>)criteria.list();
 465                         defaultBeanInitializer.initializeAll(results, propertyPaths);
 466                         return results;
 467                 } else {
 468                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(TaxonNameBase.class,auditEvent.getRevisionNumber());
 469
 470                         if(genusOrUninomial != null) {
 471                                 query.add(AuditEntity.property("genusOrUninomial").eq(genusOrUninomial));
 472                         } else {
 473                                 query.add(AuditEntity.property("genusOrUninomial").isNull());
 474                         }
 475
 476                         if(infraGenericEpithet != null) {
 477                                 query.add(AuditEntity.property("infraGenericEpithet").eq(infraGenericEpithet));
 478                         } else {
 479                                 query.add(AuditEntity.property("infraGenericEpithet").isNull());
 480                         }
 481
 482                         if(specificEpithet != null) {
 483                                 query.add(AuditEntity.property("specificEpithet").eq(specificEpithet));
 484                         } else {
 485                                 query.add(AuditEntity.property("specificEpithet").isNull());
 486                         }
 487
 488                         if(infraSpecificEpithet != null) {
 489                                 query.add(AuditEntity.property("infraSpecificEpithet").eq(infraSpecificEpithet));
 490                         } else {
 491                                 query.add(AuditEntity.property("infraSpecificEpithet").isNull());
 492                         }
 493
 494                         if(rank != null) {
 495                                 query.add(AuditEntity.relatedId("rank").eq(rank.getId()));
 496                         }
 497
 498                         if(pageSize != null) {
 499                                 query.setMaxResults(pageSize);
 500                                 if(pageNumber != null) {
 501                                         query.setFirstResult(pageNumber * pageSize);
 502                                 } else {
 503                                         query.setFirstResult(0);
 504                                 }
 505                         }
 506
 507                         List<TaxonNameBase> results = (List<TaxonNameBase>)query.getResultList();
 508                         defaultBeanInitializer.initializeAll(results, propertyPaths);
 509                         return results;
 510                 }
 511         }
 512
 513         public List<? extends TaxonNameBase<?,?>> findByName(String queryString,
 514                         MatchMode matchmode, Integer pageSize, Integer pageNumber, List<Criterion> criteria, List<String> propertyPaths) {
 515
 516                 Criteria crit = getSession().createCriteria(type);
 517                 if (matchmode == MatchMode.EXACT) {
 518                         crit.add(Restrictions.eq("nameCache", matchmode.queryStringFrom(queryString)));
 519                 } else {
 520                         crit.add(Restrictions.ilike("nameCache", matchmode.queryStringFrom(queryString)));
 521                 }
 522                 if(criteria != null){
 523                         for (Criterion criterion : criteria) {
 524                                 crit.add(criterion);
 525                         }
 526                 }
 527                 crit.addOrder(Order.asc("nameCache"));
 528
 529                 if(pageSize != null) {
 530                         crit.setMaxResults(pageSize);
 531                         if(pageNumber != null) {
 532                                 crit.setFirstResult(pageNumber * pageSize);
 533                         }
 534                 }
 535
 536                 List<? extends TaxonNameBase<?,?>> results = crit.list();
 537                 defaultBeanInitializer.initializeAll(results, propertyPaths);
 538
 539                 return results;
 540         }
 541
 542         public List<RelationshipBase> getAllRelationships(Integer limit, Integer start) {
 543                 AuditEvent auditEvent = getAuditEventFromContext();
 544                 if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
 545                     //FIXME only NameRelationships
 546                         Criteria criteria = getSession().createCriteria(RelationshipBase.class);
 547                     return (List<RelationshipBase>)criteria.list();
 548                 } else {
 549                         AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(RelationshipBase.class,auditEvent.getRevisionNumber());
 550                         return (List<RelationshipBase>)query.getResultList();
 551                 }
 552         }
 553
 554
 555         public Integer countByName(String queryString, MatchMode matchmode, List<Criterion> criteria) {
 556                 //TODO improve performance
 557                 List<? extends TaxonNameBase<?,?>> results = findByName(queryString, matchmode, null, null, criteria, null);
 558                 return results.size();
 559
 560         }
 561
 562         /* (non-Javadoc)
 563          * @see eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao#getUuidAndTitleCacheOfNames()
 564          */
 565         public List<UuidAndTitleCache> getUuidAndTitleCacheOfNames() {
 566                 String queryString = "SELECT uuid, fullTitleCache FROM TaxonNameBase";
 567
 568                 List<Object[]> result = getSession().createSQLQuery(queryString).list();
 569
 570                 if(result.size() == 0){
 571                         return null;
 572                 }else{
 573                         List<UuidAndTitleCache> list = new ArrayList<UuidAndTitleCache>(result.size());
 574
 575                         for (Object object : result){
 576
 577                                 Object[] objectArray = (Object[]) object;
 578
 579                                 UUID uuid = UUID.fromString((String) objectArray[0]);
 580                                 String titleCache = (String) objectArray[1];
 581
 582                                 list.add(new UuidAndTitleCache(type, uuid, titleCache));
 583                         }
 584
 585                         return list;
 586                 }
 587         }
 588
 589         public Integer countByName(Class<? extends TaxonNameBase> clazz,String queryString, MatchMode matchmode, List<Criterion> criteria) {
 590         return super.countByParam(clazz, "nameCache", queryString, matchmode, criteria);
 591         }
 592
 593         public List<TaxonNameBase> findByName(Class<? extends TaxonNameBase> clazz,     String queryString, MatchMode matchmode, List<Criterion> criteria,Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,     List<String> propertyPaths) {
 594                 return super.findByParam(clazz, "nameCache", queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 595         }
 596
 597         public UUID delete (TaxonNameBase persistentObject){
 598                 Set<TaxonBase> taxonBases = persistentObject.getTaxonBases();
 599                 super.delete(persistentObject);
 600
 601                 for (TaxonBase taxonBase: taxonBases){
 602                         taxonDao.delete(taxonBase);
 603                 }
 604                 return persistentObject.getUuid();
 605         }
 606
 607         public List<ZoologicalName> getAllZoologicalNames(Integer limit, Integer start){
 608                 List <TaxonNameBase> names = new ArrayList<TaxonNameBase>();
 609                 List <ZoologicalName> zooNames = new ArrayList<ZoologicalName>();
 610                 names = super.list(ZoologicalName.class, limit, start);
 611                 for (TaxonNameBase name: names){
 612                         zooNames.add((ZoologicalName)name);
 613                 }
 614                 return zooNames;
 615         }
 616
 617         public ZoologicalName findZoologicalNameByUUID(UUID uuid){
 618                 Criteria criteria = getSession().createCriteria(type);
 619                 if (uuid != null) {
 620                         criteria.add(Restrictions.eq("uuid", uuid));
 621                 } else {
 622                         logger.error("UUID is NULL");
 623                         return null;
 624                 }
 625
 626                 List<? extends TaxonNameBase<?,?>> results = criteria.list();
 627                 if (results.size() == 1) {
 628                         defaultBeanInitializer.initializeAll(results, null);
 629                         TaxonNameBase<?, ?> taxonName = results.iterator().next();
 630                         if (taxonName.isInstanceOf(ZoologicalName.class)) {
 631                                 ZoologicalName zoologicalName = CdmBase.deproxy(taxonName, ZoologicalName.class);
 632                                 return zoologicalName;
 633                         } else {
 634                                 logger.warn("This UUID (" + uuid + ") does not belong to a ZoologicalName. It belongs to: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");
 635                         }
 636                 } else if (results.size() > 1) {
 637                         logger.warn("Multiple results for UUID: " + uuid);
 638                 } else if (results.size() == 0) {
 639                         logger.warn("No results for UUID: " + uuid);
 640                 }
 641                 return null;
 642         }
 643
 644 }