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