models-dao/src/main/java/org/onap/policy/models/dao/impl/DefaultPfDao.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019-2021 Nordix Foundation.
   4  *  Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.models.dao.impl;
  23
  24 import java.sql.Timestamp;
  25 import java.time.Instant;
  26 import java.util.Collection;
  27 import java.util.Collections;
  28 import java.util.List;
  29 import java.util.Map;
  30 import javax.persistence.EntityManager;
  31 import javax.persistence.EntityManagerFactory;
  32 import javax.persistence.Persistence;
  33 import javax.persistence.TypedQuery;
  34 import javax.ws.rs.core.Response;
  35 import org.onap.policy.models.base.PfConcept;
  36 import org.onap.policy.models.base.PfConceptKey;
  37 import org.onap.policy.models.base.PfGeneratedIdKey;
  38 import org.onap.policy.models.base.PfModelException;
  39 import org.onap.policy.models.base.PfModelRuntimeException;
  40 import org.onap.policy.models.base.PfReferenceKey;
  41 import org.onap.policy.models.base.PfReferenceTimestampKey;
  42 import org.onap.policy.models.base.PfTimestampKey;
  43 import org.onap.policy.models.base.PfUtils;
  44 import org.onap.policy.models.dao.DaoParameters;
  45 import org.onap.policy.models.dao.PfDao;
  46 import org.onap.policy.models.dao.PfFilter;
  47 import org.onap.policy.models.dao.PfFilterFactory;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 /**
  52  * The Class DefaultPfDao is an JPA implementation of the {@link PfDao} class for Policy Framework concepts
  53  * ({@link PfConcept}). It uses the default JPA implementation in the javax {@link Persistence} class.
  54  */
  55 public class DefaultPfDao implements PfDao {
  56     private static final Logger LOGGER = LoggerFactory.getLogger(DefaultPfDao.class);
  57
  58     // @formatter:off
  59     private static final String NAME           = "name";
  60     private static final String VERSION        = "version";
  61     private static final String TIMESTAMP      = "timeStamp";
  62     private static final String GENERATEDID    = "Id";
  63     private static final String PARENT_NAME    = "parentname";
  64     private static final String PARENT_VERSION = "parentversion";
  65     private static final String LOCAL_NAME     = "localname";
  66
  67     private static final String TABLE_TOKEN = "__TABLE__";
  68
  69     private static final String DELETE_FROM_TABLE = "DELETE FROM __TABLE__ c";
  70
  71     private static final String SELECT_FROM_TABLE = "SELECT c FROM __TABLE__ c";
  72
  73     private static final String WHERE      = " WHERE ";
  74     private static final String AND        = " AND ";
  75
  76     private static final String NAME_FILTER            = "c.key.name = :name";
  77     private static final String VERSION_FILTER         = "c.key.version = :version";
  78     private static final String TIMESTAMP_FILTER       = "c.key.timeStamp = :timeStamp";
  79     private static final String TIMESTAMP_FILTER_NOKEY = "c.timeStamp = :timeStamp";
  80     private static final String GENERATED_ID_FILTER    = "c.key.generatedId = :Id";
  81     private static final String PARENT_NAME_FILTER     = "c.key.parentKeyName = :parentname";
  82     private static final String PARENT_VERSION_FILTER  = "c.key.parentKeyVersion = :parentversion";
  83     private static final String LOCAL_NAME_FILTER      = "c.key.localName = :localname";
  84
  85     private static final String CLONE_ERR_MSG = "Could not clone object of class \"{}\"";
  86
  87     private static final String DELETE_BY_CONCEPT_KEY =
  88             DELETE_FROM_TABLE + WHERE + NAME_FILTER + AND + VERSION_FILTER;
  89
  90     private static final String DELETE_BY_TIMESTAMP_KEY =
  91             DELETE_FROM_TABLE + WHERE + NAME_FILTER + AND + VERSION_FILTER  + AND + TIMESTAMP_FILTER;
  92
  93     private static final String DELETE_BY_GENERATED_ID_KEY =
  94             DELETE_FROM_TABLE + WHERE + NAME_FILTER + AND + VERSION_FILTER  + AND + GENERATED_ID_FILTER;
  95
  96     private static final String DELETE_BY_REFERENCE_KEY =
  97             DELETE_FROM_TABLE + WHERE + PARENT_NAME_FILTER + AND + PARENT_VERSION_FILTER + AND + LOCAL_NAME_FILTER;
  98
  99     private static final String SELECT_ALL_FOR_PARENT =
 100             SELECT_FROM_TABLE + WHERE + PARENT_NAME_FILTER + AND + PARENT_VERSION_FILTER;
 101
 102     private static final String SELECT_ALL_VERSIONS_FOR_PARENT =
 103             SELECT_FROM_TABLE + WHERE + PARENT_NAME_FILTER;
 104
 105     private static final String SELECT_ALL_VERSIONS = SELECT_FROM_TABLE + WHERE + NAME_FILTER;
 106
 107     private static final String SELECT_BY_CONCEPT_KEY =
 108             SELECT_FROM_TABLE + WHERE + NAME_FILTER + AND + VERSION_FILTER;
 109
 110     private static final String SELECT_BY_TIMESTAMP_NOKEY =
 111             SELECT_FROM_TABLE + WHERE + NAME_FILTER + AND + VERSION_FILTER + AND + TIMESTAMP_FILTER_NOKEY;
 112
 113     private static final String SELECT_BY_REFERENCE_KEY =
 114             SELECT_FROM_TABLE + WHERE + PARENT_NAME_FILTER + AND + PARENT_VERSION_FILTER + AND + LOCAL_NAME_FILTER;
 115     // @formatter:on
 116
 117     // Entity manager for JPA
 118     private EntityManagerFactory emf = null;
 119
 120     @Override
 121     public void init(final DaoParameters daoParameters) throws PfModelException {
 122         if (daoParameters == null || daoParameters.getPersistenceUnit() == null) {
 123             LOGGER.error("Policy Framework persistence unit parameter not set");
 124             throw new PfModelException(Response.Status.INTERNAL_SERVER_ERROR,
 125                     "Policy Framework persistence unit parameter not set");
 126         }
 127
 128         LOGGER.debug("Creating Policy Framework persistence unit \"{}\" . . .", daoParameters.getPersistenceUnit());
 129         try {
 130             emf = Persistence.createEntityManagerFactory(daoParameters.getPersistenceUnit(),
 131                     daoParameters.getJdbcProperties());
 132         } catch (final Exception ex) {
 133             String errorMessage = "Creation of Policy Framework persistence unit \""
 134                     + daoParameters.getPersistenceUnit() + "\" failed";
 135             LOGGER.warn(errorMessage);
 136             throw new PfModelException(Response.Status.INTERNAL_SERVER_ERROR, errorMessage, ex);
 137         }
 138         LOGGER.debug("Created Policy Framework persistence unit \"{}\"", daoParameters.getPersistenceUnit());
 139     }
 140
 141     /**
 142      * Gets the entity manager for this DAO.
 143      *
 144      * @return the entity manager
 145      */
 146     protected final synchronized EntityManager getEntityManager() {
 147         if (emf == null) {
 148             LOGGER.warn("Policy Framework DAO has not been initialized");
 149             throw new PfModelRuntimeException(Response.Status.INTERNAL_SERVER_ERROR,
 150                     "Policy Framework DAO has not been initialized");
 151         }
 152
 153         return emf.createEntityManager();
 154     }
 155
 156     @Override
 157     public final void close() {
 158         if (emf != null) {
 159             emf.close();
 160         }
 161     }
 162
 163     @Override
 164     public <T extends PfConcept> void create(final T obj) {
 165         if (obj == null) {
 166             return;
 167         }
 168         final var mg = getEntityManager();
 169         try {
 170             mg.getTransaction().begin();
 171             mg.merge(obj);
 172             mg.getTransaction().commit();
 173         } finally {
 174             mg.close();
 175         }
 176     }
 177
 178     @Override
 179     public <T extends PfConcept> void delete(final T obj) {
 180         if (obj == null) {
 181             return;
 182         }
 183         final var mg = getEntityManager();
 184         try {
 185             mg.getTransaction().begin();
 186             mg.remove(mg.contains(obj) ? obj : mg.merge(obj));
 187             mg.getTransaction().commit();
 188         } finally {
 189             mg.close();
 190         }
 191     }
 192
 193     @Override
 194     public <T extends PfConcept> void delete(final Class<T> someClass, final PfConceptKey key) {
 195         if (key == null) {
 196             return;
 197         }
 198         final var mg = getEntityManager();
 199         try {
 200             // @formatter:off
 201             mg.getTransaction().begin();
 202             mg.createQuery(setQueryTable(DELETE_BY_CONCEPT_KEY, someClass), someClass)
 203                 .setParameter(NAME,    key.getName())
 204                 .setParameter(VERSION, key.getVersion())
 205                 .executeUpdate();
 206             mg.getTransaction().commit();
 207             // @formatter:on
 208         } finally {
 209             mg.close();
 210         }
 211     }
 212
 213     @Override
 214     public <T extends PfConcept> void delete(final Class<T> someClass, final PfReferenceKey key) {
 215         if (key == null) {
 216             return;
 217         }
 218         final var mg = getEntityManager();
 219         try {
 220             // @formatter:off
 221             mg.getTransaction().begin();
 222             mg.createQuery(setQueryTable(DELETE_BY_REFERENCE_KEY, someClass), someClass)
 223                 .setParameter(PARENT_NAME,    key.getParentKeyName())
 224                 .setParameter(PARENT_VERSION, key.getParentKeyVersion())
 225                 .setParameter(LOCAL_NAME,     key.getLocalName())
 226                 .executeUpdate();
 227             mg.getTransaction().commit();
 228             // @formatter:on
 229         } finally {
 230             mg.close();
 231         }
 232     }
 233
 234     @Override
 235     public <T extends PfConcept> void delete(final Class<T> someClass, final PfTimestampKey key) {
 236         if (key == null) {
 237             return;
 238         }
 239         final var mg = getEntityManager();
 240         try {
 241             // @formatter:off
 242             mg.getTransaction().begin();
 243             mg.createQuery(setQueryTable(DELETE_BY_TIMESTAMP_KEY, someClass), someClass)
 244                     .setParameter(NAME,    key.getName())
 245                     .setParameter(VERSION, key.getVersion())
 246                     .setParameter(TIMESTAMP, key.getTimeStamp())
 247                     .executeUpdate();
 248             mg.getTransaction().commit();
 249             // @formatter:on
 250         } finally {
 251             mg.close();
 252         }
 253     }
 254
 255     @Override
 256     public <T extends PfConcept> void delete(final Class<T> someClass, final PfGeneratedIdKey key) {
 257         if (key == null) {
 258             return;
 259         }
 260         final var mg = getEntityManager();
 261         try {
 262             // @formatter:off
 263             mg.getTransaction().begin();
 264             mg.createQuery(setQueryTable(DELETE_BY_GENERATED_ID_KEY, someClass), someClass)
 265                     .setParameter(NAME,    key.getName())
 266                     .setParameter(VERSION, key.getVersion())
 267                     .setParameter(GENERATEDID, key.getGeneratedId())
 268                     .executeUpdate();
 269             mg.getTransaction().commit();
 270             // @formatter:on
 271         } finally {
 272             mg.close();
 273         }
 274     }
 275
 276     @Override
 277     public <T extends PfConcept> void createCollection(final Collection<T> objs) {
 278         if (objs == null || objs.isEmpty()) {
 279             return;
 280         }
 281         final var mg = getEntityManager();
 282         try {
 283             mg.getTransaction().begin();
 284             for (final T t : objs) {
 285                 mg.merge(t);
 286             }
 287             mg.getTransaction().commit();
 288         } finally {
 289             mg.close();
 290         }
 291     }
 292
 293     @Override
 294     public <T extends PfConcept> void deleteCollection(final Collection<T> objs) {
 295         if (objs == null || objs.isEmpty()) {
 296             return;
 297         }
 298         final var mg = getEntityManager();
 299         try {
 300             mg.getTransaction().begin();
 301             for (final T t : objs) {
 302                 mg.remove(mg.contains(t) ? t : mg.merge(t));
 303             }
 304             mg.getTransaction().commit();
 305         } finally {
 306             mg.close();
 307         }
 308     }
 309
 310     @Override
 311     public <T extends PfConcept> int deleteByConceptKey(final Class<T> someClass, final Collection<PfConceptKey> keys) {
 312         if (keys == null || keys.isEmpty()) {
 313             return 0;
 314         }
 315         var deletedCount = 0;
 316         final var mg = getEntityManager();
 317         try {
 318             // @formatter:off
 319             mg.getTransaction().begin();
 320             for (final PfConceptKey key : keys) {
 321                 deletedCount += mg.createQuery(setQueryTable(DELETE_BY_CONCEPT_KEY, someClass), someClass)
 322                     .setParameter(NAME,    key.getName())
 323                     .setParameter(VERSION, key.getVersion())
 324                     .executeUpdate();
 325             }
 326             mg.getTransaction().commit();
 327             // @formatter:on
 328         } finally {
 329             mg.close();
 330         }
 331         return deletedCount;
 332     }
 333
 334     @Override
 335     public <T extends PfConcept> int deleteByReferenceKey(final Class<T> someClass,
 336             final Collection<PfReferenceKey> keys) {
 337         if (keys == null || keys.isEmpty()) {
 338             return 0;
 339         }
 340         var deletedCount = 0;
 341         final var mg = getEntityManager();
 342         try {
 343             // @formatter:off
 344             mg.getTransaction().begin();
 345             for (final PfReferenceKey key : keys) {
 346                 deletedCount += mg.createQuery(setQueryTable(DELETE_BY_REFERENCE_KEY, someClass), someClass)
 347                     .setParameter(PARENT_NAME,    key.getParentKeyName())
 348                     .setParameter(PARENT_VERSION, key.getParentKeyVersion())
 349                     .setParameter(LOCAL_NAME,     key.getLocalName())
 350                     .executeUpdate();
 351             }
 352             mg.getTransaction().commit();
 353             // @formatter:on
 354         } finally {
 355             mg.close();
 356         }
 357         return deletedCount;
 358     }
 359
 360     @Override
 361     public <T extends PfConcept> void deleteAll(final Class<T> someClass) {
 362         final var mg = getEntityManager();
 363         try {
 364             mg.getTransaction().begin();
 365             mg.createQuery(setQueryTable(DELETE_FROM_TABLE, someClass), someClass).executeUpdate();
 366             mg.getTransaction().commit();
 367         } finally {
 368             mg.close();
 369         }
 370     }
 371
 372     @Override
 373     public <T extends PfConcept> List<T> getFiltered(final Class<T> someClass, final String name,
 374             final String version) {
 375         if (name == null) {
 376             return getAll(someClass);
 377         }
 378
 379         if (version == null) {
 380             return getAllVersions(someClass, name);
 381         }
 382
 383         var foundConcept = get(someClass, new PfConceptKey(name, version));
 384
 385         return (foundConcept == null ? Collections.emptyList() : Collections.singletonList(foundConcept));
 386     }
 387
 388     @Override
 389     public <T extends PfConcept> List<T> getFiltered(final Class<T> someClass, final String name, final String version,
 390             final Instant startTime, final Instant endTime, final Map<String, Object> filterMap, final String sortOrder,
 391             final int getRecordNum) {
 392         final var mg = getEntityManager();
 393
 394         var filterQueryString = SELECT_FROM_TABLE + WHERE;
 395
 396         try {
 397             PfFilter timeStampFilter = new PfFilterFactory().createFilter(someClass);
 398             filterQueryString = timeStampFilter.addFilter(filterQueryString,
 399                   name, startTime, endTime, filterMap, sortOrder, getRecordNum);
 400
 401
 402             TypedQuery<T> query = mg.createQuery(setQueryTable(filterQueryString, someClass), someClass);
 403
 404             if (filterMap != null) {
 405                 for (Map.Entry<String, Object> entry : filterMap.entrySet()) {
 406                     query.setParameter(entry.getKey(), entry.getValue());
 407                 }
 408             }
 409             if (name != null) {
 410                 query.setParameter(timeStampFilter.getNameParameter(), name);
 411             }
 412             if (startTime != null) {
 413                 if (endTime != null) {
 414                     query.setParameter("startTime", Timestamp.from(startTime));
 415                     query.setParameter("endTime", Timestamp.from(endTime));
 416                 } else {
 417                     query.setParameter("startTime", Timestamp.from(startTime));
 418                 }
 419             } else {
 420                 if (endTime != null) {
 421                     query.setParameter("endTime", Timestamp.from(endTime));
 422                 }
 423             }
 424             if (getRecordNum > 0) {
 425                 query.setMaxResults(getRecordNum);
 426             }
 427
 428             LOGGER.debug("filterQueryString is  \"{}\"", filterQueryString);
 429             return query.getResultList();
 430         }  finally {
 431             mg.close();
 432         }
 433     }
 434
 435     @Override
 436     public <T extends PfConcept> T get(final Class<T> someClass, final PfConceptKey key) {
 437         return genericGet(someClass, key);
 438     }
 439
 440     @Override
 441     public <T extends PfConcept> T get(final Class<T> someClass, final PfReferenceKey key) {
 442         return genericGet(someClass, key);
 443     }
 444
 445     @Override
 446     public <T extends PfConcept> T get(final Class<T> someClass, final PfGeneratedIdKey key) {
 447         return genericGet(someClass, key);
 448     }
 449
 450     @Override
 451     public <T extends PfConcept> T get(final Class<T> someClass, final PfTimestampKey key) {
 452         return genericGet(someClass, key);
 453     }
 454
 455     @Override
 456     public <T extends PfConcept> T get(final Class<T> someClass, final PfReferenceTimestampKey key) {
 457         return genericGet(someClass, key);
 458     }
 459
 460     private <T extends PfConcept> T genericGet(final Class<T> someClass, final Object key) {
 461         if (someClass == null) {
 462             return null;
 463         }
 464         final var mg = getEntityManager();
 465         try {
 466             final var t = mg.find(someClass, key);
 467             if (t != null) {
 468                 mg.refresh(t);
 469             }
 470             return checkAndReturn(someClass, t);
 471         } finally {
 472             mg.close();
 473         }
 474     }
 475
 476     @Override
 477     public <T extends PfConcept> List<T> getAll(final Class<T> someClass) {
 478         if (someClass == null) {
 479             return Collections.emptyList();
 480         }
 481         final var mg = getEntityManager();
 482         try {
 483             return mg.createQuery(setQueryTable(SELECT_FROM_TABLE, someClass), someClass).getResultList();
 484         } finally {
 485             mg.close();
 486         }
 487     }
 488
 489     @Override
 490     public <T extends PfConcept> List<T> getAll(final Class<T> someClass, final PfConceptKey parentKey) {
 491         if (someClass == null) {
 492             return Collections.emptyList();
 493         }
 494         final var mg = getEntityManager();
 495         try {
 496             // @formatter:off
 497             return mg.createQuery(setQueryTable(SELECT_ALL_FOR_PARENT, someClass), someClass)
 498                     .setParameter(PARENT_NAME,    parentKey.getName())
 499                     .setParameter(PARENT_VERSION, parentKey.getVersion())
 500                     .getResultList();
 501             // @formatter:on
 502         } finally {
 503             mg.close();
 504         }
 505     }
 506
 507     @Override
 508     public <T extends PfConcept> List<T> getAllVersionsByParent(final Class<T> someClass, final String parentKeyName) {
 509         if (someClass == null || parentKeyName == null) {
 510             return Collections.emptyList();
 511         }
 512         final var mg = getEntityManager();
 513         try {
 514             // @formatter:off
 515             return mg.createQuery(setQueryTable(SELECT_ALL_VERSIONS_FOR_PARENT, someClass), someClass)
 516                     .setParameter(PARENT_NAME, parentKeyName)
 517                     .getResultList();
 518             // @formatter:on
 519         } finally {
 520             mg.close();
 521         }
 522     }
 523
 524     @Override
 525     public <T extends PfConcept> List<T> getAllVersions(final Class<T> someClass, final String conceptName) {
 526         if (someClass == null || conceptName == null) {
 527             return Collections.emptyList();
 528         }
 529         final var mg = getEntityManager();
 530         try {
 531             // @formatter:off
 532             return mg.createQuery(setQueryTable(SELECT_ALL_VERSIONS, someClass), someClass)
 533                     .setParameter(NAME, conceptName)
 534                     .getResultList();
 535             // @formatter:on
 536         } finally {
 537             mg.close();
 538         }
 539     }
 540
 541     @Override
 542     public <T extends PfConcept> List<T> getByTimestamp(final Class<T> someClass,
 543                                                         final PfGeneratedIdKey key,
 544                                                         final Instant timeStamp) {
 545         if (someClass == null || key == null || timeStamp == null) {
 546             return Collections.emptyList();
 547         }
 548
 549         final var mg = getEntityManager();
 550         try {
 551             // @formatter:off
 552             return mg.createQuery(setQueryTable(SELECT_BY_TIMESTAMP_NOKEY, someClass), someClass)
 553                     .setParameter(NAME,    key.getName())
 554                     .setParameter(VERSION, key.getVersion())
 555                     .setParameter(TIMESTAMP, Timestamp.from(timeStamp))
 556                     .getResultList();
 557             // @formatter:on
 558         } finally {
 559             mg.close();
 560         }
 561     }
 562
 563     @Override
 564     public <T extends PfConcept> T getConcept(final Class<T> someClass, final PfConceptKey key) {
 565         if (someClass == null || key == null) {
 566             return null;
 567         }
 568         final var mg = getEntityManager();
 569         List<T> ret;
 570         try {
 571             // @formatter:off
 572             ret = mg.createQuery(setQueryTable(SELECT_BY_CONCEPT_KEY, someClass), someClass)
 573                     .setParameter(NAME,    key.getName())
 574                     .setParameter(VERSION, key.getVersion())
 575                     .getResultList();
 576             // @formatter:on
 577         } finally {
 578             mg.close();
 579         }
 580
 581         return getSingleResult(someClass, key.getId(), ret);
 582     }
 583
 584     @Override
 585     public <T extends PfConcept> T getConcept(final Class<T> someClass, final PfReferenceKey key) {
 586         if (someClass == null || key == null) {
 587             return null;
 588         }
 589         final var mg = getEntityManager();
 590         List<T> ret;
 591         try {
 592             // @formatter:off
 593             ret = mg.createQuery(setQueryTable(SELECT_BY_REFERENCE_KEY, someClass), someClass)
 594                     .setParameter(PARENT_NAME,    key.getParentKeyName())
 595                     .setParameter(PARENT_VERSION, key.getParentKeyVersion())
 596                     .setParameter(LOCAL_NAME,     key.getLocalName())
 597                     .getResultList();
 598             // @formatter:on
 599         } finally {
 600             mg.close();
 601         }
 602
 603         return getSingleResult(someClass, key.getId(), ret);
 604     }
 605
 606     @Override
 607     public <T extends PfConcept> T update(final T obj) {
 608         final var mg = getEntityManager();
 609         T ret;
 610         try {
 611             mg.getTransaction().begin();
 612             ret = mg.merge(obj);
 613             mg.flush();
 614             mg.getTransaction().commit();
 615         } finally {
 616             mg.close();
 617         }
 618         return ret;
 619     }
 620
 621     @Override
 622     public <T extends PfConcept> long size(final Class<T> someClass) {
 623         if (someClass == null) {
 624             return 0;
 625         }
 626         final var mg = getEntityManager();
 627         long size = 0;
 628         try {
 629             size = mg.createQuery("SELECT COUNT(c) FROM " + someClass.getSimpleName() + " c", Long.class)
 630                     .getSingleResult();
 631         } finally {
 632             mg.close();
 633         }
 634         return size;
 635     }
 636
 637     /**
 638      * Add the table to a query string.
 639      *
 640      * @param queryString the query string
 641      * @param tableClass the class name of the table
 642      * @return the updated query string
 643      */
 644     private <T extends PfConcept> String setQueryTable(final String queryString, final Class<T> tableClass) {
 645         return queryString.replace(TABLE_TOKEN, tableClass.getSimpleName());
 646     }
 647
 648     /**
 649      * Check that a query returned one and only one entry and return that entry.
 650      *
 651      * @param someClass the class being searched for
 652      * @param conceptName the concept name being searched for
 653      * @param resultList the result list returned by the query
 654      * @return the single unique result
 655      */
 656     private <T extends PfConcept> T getSingleResult(final Class<T> someClass, final String searchFilter, List<T> ret) {
 657         if (ret == null || ret.isEmpty()) {
 658             return null;
 659         }
 660         if (ret.size() > 1) {
 661             throw new IllegalArgumentException("More than one result was returned query on " + someClass
 662                     + " with filter " + searchFilter + ": " + ret);
 663         }
 664         return ret.get(0);
 665     }
 666
 667     /**
 668      * check the result get from database and return the object.
 669      *
 670      * @param <T> the type of the object to get, a subclass of {@link PfConcept}
 671      * @param someClass the class of the object to get, a subclass of {@link PfConcept}
 672      * @param t the object that was retrieved from the database
 673      * @return the checked object or null
 674      */
 675     private <T extends PfConcept> T checkAndReturn(final Class<T> someClass, final T objToCheck) {
 676         if (objToCheck != null) {
 677             try {
 678                 return PfUtils.makeCopy(objToCheck);
 679             } catch (final Exception e) {
 680                 LOGGER.warn(CLONE_ERR_MSG, someClass.getName(), e);
 681             }
 682         }
 683         return null;
 684     }
 685 }