Example #1
0
  @Override
  public void clear() {
    EntityManager em = emf.createEntityManager();
    EntityTransaction txn = em.getTransaction();

    try {
      // the clear operation often deadlocks - let's try several times
      for (int i = 0; ; ++i) {
        txn.begin();
        try {
          log.trace("Clearing JPA Store");
          String entityTable = em.getMetamodel().entity(configuration.entityClass()).getName();
          @SuppressWarnings("unchecked")
          List<Object> items = em.createQuery("FROM " + entityTable).getResultList();
          for (Object o : items) em.remove(o);
          if (configuration.storeMetadata()) {
            String metadataTable = em.getMetamodel().entity(MetadataEntity.class).getName();
            Query clearMetadata = em.createQuery("DELETE FROM " + metadataTable);
            clearMetadata.executeUpdate();
          }
          txn.commit();
          em.clear();
          break;
        } catch (Exception e) {
          log.trace("Failed to clear store", e);
          if (i >= 10) throw new JpaStoreException("Exception caught in clear()", e);
        } finally {
          if (txn != null && txn.isActive()) txn.rollback();
        }
      }
    } finally {
      em.close();
    }
  }
  public void testMetamodelOnClauseWithLeftJoin() {
    EntityManager em = createEntityManager();
    Query query =
        em.createQuery(
            "Select e from Employee e left join e.address a on a.city = 'Ottawa' "
                + "where a.postalCode is not null");
    List baseResult = query.getResultList();

    Metamodel metamodel = em.getMetamodel();
    EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class);
    EntityType<Address> entityAddr_ = metamodel.entity(Address.class);

    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
    Root<Employee> root = cq.from(entityEmp_);
    Join address = root.join(entityEmp_.getSingularAttribute("address"), JoinType.LEFT);
    address.on(qb.equal(address.get(entityAddr_.getSingularAttribute("city")), "Ottawa"));
    cq.where(qb.isNotNull(address.get(entityAddr_.getSingularAttribute("postalCode"))));
    List testResult = em.createQuery(cq).getResultList();

    clearCache();
    closeEntityManager(em);

    if (baseResult.size() != testResult.size()) {
      fail(
          "Criteria query using ON clause with a left join did not match JPQL results; "
              + baseResult.size()
              + " were expected, while criteria query returned "
              + testResult.size());
    }
  }
Example #3
0
 /**
  * Invoke byExample method for each not null x-to-one association when their pk is not set. This
  * allows you to search entities based on an associated entity's properties value.
  */
 @SuppressWarnings("unchecked")
 public <T extends Identifiable<?>, M2O extends Identifiable<?>> List<Predicate> byExampleOnXToOne(
     ManagedType<T> mt,
     Root<T> mtPath,
     final T mtValue,
     SearchParameters sp,
     CriteriaBuilder builder) {
   List<Predicate> predicates = newArrayList();
   for (SingularAttribute<? super T, ?> attr : mt.getSingularAttributes()) {
     if (attr.getPersistentAttributeType() == MANY_TO_ONE
         || attr.getPersistentAttributeType() == ONE_TO_ONE) {
       M2O m2oValue = (M2O) JpaUtil.getValue(mtValue, mt.getAttribute(attr.getName()));
       Class<M2O> m2oType = (Class<M2O>) attr.getBindableJavaType();
       Path<M2O> m2oPath = (Path<M2O>) mtPath.get(attr);
       ManagedType<M2O> m2oMt = em.getMetamodel().entity(m2oType);
       if (m2oValue != null) {
         if (m2oValue.isIdSet()) { // we have an id, let's restrict only on this field
           predicates.add(builder.equal(m2oPath.get("id"), m2oValue.getId()));
         } else {
           predicates.addAll(byExample(m2oMt, m2oPath, m2oValue, sp, builder));
         }
       }
     }
   }
   return predicates;
 }
 /**
  * Automatically retrieve ID from entity instance.
  *
  * @param obj The object from whom we need primary key
  * @return The corresponding primary key.
  */
 @SuppressWarnings({"rawtypes", "unchecked"})
 protected ID getIdFromEntity(T obj) {
   MetamodelUtils utils =
       new MetamodelUtils<T, ID>(
           (Class<T>) ClassUtils.getGenericTypeFromBean(this.service), em.getMetamodel());
   return (ID) utils.getIdFromEntity(obj);
 }
  @Override
  public Metamodel getMetamodel() {
    EntityManager em = getCurrent();

    if (em != null) {
      return em.getMetamodel();
    }

    em = createEntityManager();

    try {
      return em.getMetamodel();
    } finally {
      freeEntityManager(em);
    }
  }
  public void testMetamodelOnClauseOverCollection() {
    EntityManager em = createEntityManager();
    Query query =
        em.createQuery("Select e from Employee e join e.phoneNumbers p on p.areaCode = '613'");
    List baseResult = query.getResultList();

    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
    Metamodel metamodel = em.getMetamodel();
    EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class);
    EntityType<PhoneNumber> entityPhone_ = metamodel.entity(PhoneNumber.class);

    Root<Employee> root = cq.from(entityEmp_);
    Join phoneNumber = root.join(entityEmp_.getCollection("phoneNumbers"));
    phoneNumber.on(qb.equal(phoneNumber.get(entityPhone_.getSingularAttribute("areaCode")), "613"));
    List testResult = em.createQuery(cq).getResultList();

    clearCache();
    closeEntityManager(em);

    if (baseResult.size() != testResult.size()) {
      fail(
          "Criteria query using ON clause did not match JPQL results; "
              + baseResult.size()
              + " were expected, while criteria query returned "
              + testResult.size());
    }
  }
  @Bean
  public CacheManager cacheManager() {
    log.debug("Starting Ehcache");
    cacheManager = net.sf.ehcache.CacheManager.create();
    cacheManager
        .getConfiguration()
        .setMaxBytesLocalHeap(
            env.getProperty("cache.ehcache.maxBytesLocalHeap", String.class, "16M"));
    log.debug("Registering Ehcache Metrics gauges");
    Set<EntityType<?>> entities = entityManager.getMetamodel().getEntities();
    for (EntityType<?> entity : entities) {

      String name = entity.getName();
      if (name == null || entity.getJavaType() != null) {
        name = entity.getJavaType().getName();
      }
      Assert.notNull(name, "entity cannot exist without a identifier");

      net.sf.ehcache.Cache cache = cacheManager.getCache(name);
      if (cache != null) {
        cache
            .getCacheConfiguration()
            .setTimeToLiveSeconds(env.getProperty("cache.timeToLiveSeconds", Long.class, 3600L));
        net.sf.ehcache.Ehcache decoratedCache =
            InstrumentedEhcache.instrument(metricRegistry, cache);
        cacheManager.replaceCacheWithDecoratedCache(cache, decoratedCache);
      }
    }
    EhCacheCacheManager ehCacheManager = new EhCacheCacheManager();
    ehCacheManager.setCacheManager(cacheManager);
    return ehCacheManager;
  }
 private synchronized void reloadCache(EntityManager em) {
   if (em == null || ref.get() != null) return;
   Metamodel metamodel = em.getMetamodel();
   Map<String, Class<?>> map = new HashMap<>(metamodel.getEntities().size() + 2);
   for (EntityType<?> entity : metamodel.getEntities()) {
     System.out.printf(
         "---  Carregando do Metamodel: %s [%s] \n", entity.getName(), entity.getJavaType());
     map.put(entity.getName(), entity.getJavaType());
   }
   ref = new SoftReference(map);
 }
 @Test
 @Sql(
     statements = {
       "INSERT INTO Person (id, firstName, lastName)" + " VALUES (42, 'John', 'Smith')"
     })
 public void testGenerateSchema() throws Exception {
   entityManager.getMetamodel().entity(Person.class);
   // When the above call does not throw an exception,
   // the Person class is mapped as a persistent entity.
   Person p = entityManager.find(Person.class, 42L);
   assertEquals("John", p.getFirstName());
   assertEquals("Smith", p.getLastName());
 }
  public void testMetamodelCriteriaDelete() {
    if ((getPersistenceUnitServerSession()).getPlatform().isSymfoware()) {
      getPersistenceUnitServerSession()
          .logMessage(
              "Test simpleDelete skipped for this platform, "
                  + "Symfoware doesn't support UpdateAll/DeleteAll on multi-table objects (see rfe 298193).");
      return;
    }
    EntityManager em = createEntityManager();
    try {
      beginTransaction(em);
      int nrOfEmps =
          ((Number)
                  em.createQuery(
                          "SELECT COUNT(phone) FROM PhoneNumber phone where phone.owner.firstName is not null")
                      .getSingleResult())
              .intValue();

      Metamodel metamodel = em.getMetamodel();
      EntityType<PhoneNumber> entityPhone_ = metamodel.entity(PhoneNumber.class);
      EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class);

      // test query "Delete Employee e where e.firstName is not null";
      CriteriaBuilder qb = em.getCriteriaBuilder();
      CriteriaDelete<PhoneNumber> cq = qb.createCriteriaDelete(PhoneNumber.class);
      Root<PhoneNumber> root = cq.from(entityPhone_);
      cq.where(
          qb.isNotNull(
              root.get(entityPhone_.getSingularAttribute("owner", Employee.class))
                  .get(entityEmp_.getSingularAttribute("firstName"))));
      Query testQuery = em.createQuery(cq);

      int updated = testQuery.executeUpdate();
      assertEquals(
          "testCriteriaDelete: wrong number of deleted instances" + updated, nrOfEmps, updated);

      // check database changes
      int nr =
          ((Number)
                  em.createQuery(
                          "SELECT COUNT(phone) FROM PhoneNumber phone where phone.owner.firstName is not null")
                      .getSingleResult())
              .intValue();
      assertEquals("testCriteriaDelete: found " + nr + " PhoneNumbers after delete all", 0, nr);
    } finally {
      if (isTransactionActive(em)) {
        rollbackTransaction(em);
      }
      closeEntityManager(em);
    }
  }
  public void testMetamodelCriteriaUpdate() {
    if ((getPersistenceUnitServerSession()).getPlatform().isSymfoware()) {
      getPersistenceUnitServerSession()
          .logMessage(
              "Test simpleUpdate skipped for this platform, "
                  + "Symfoware doesn't support UpdateAll/DeleteAll on multi-table objects (see rfe 298193).");
      return;
    }
    EntityManager em = createEntityManager();
    int nrOfEmps =
        ((Number)
                em.createQuery("SELECT COUNT(e) FROM Employee e where e.firstName is not null")
                    .getSingleResult())
            .intValue();

    Metamodel metamodel = em.getMetamodel();
    EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class);

    // test query "UPDATE Employee e SET e.firstName = 'CHANGED' where e.firstName is not null";
    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaUpdate<Employee> cq = qb.createCriteriaUpdate(Employee.class);
    Root<Employee> root = cq.from(entityEmp_);
    cq.set(root.get(entityEmp_.getSingularAttribute("firstName", String.class)), "CHANGED");
    cq.where(qb.isNotNull(root.get(entityEmp_.getSingularAttribute("firstName"))));

    beginTransaction(em);
    try {
      Query q = em.createQuery(cq);
      int updated = q.executeUpdate();
      assertEquals(
          "simpleCriteriaUpdateTest: wrong number of updated instances", nrOfEmps, updated);

      // check database changes
      int nr =
          ((Number)
                  em.createQuery("SELECT COUNT(e) FROM Employee e WHERE e.firstName = 'CHANGED'")
                      .getSingleResult())
              .intValue();
      assertEquals(
          "simpleCriteriaUpdateTest: unexpected number of changed values in the database",
          nrOfEmps,
          nr);
    } finally {
      if (isTransactionActive(em)) {
        rollbackTransaction(em);
      }
      closeEntityManager(em);
    }
  }
  // test ejbqlString = "Update Employee e set e.lastName = case when e.firstName = 'Bob' then
  // 'Jones' when e.firstName = 'Jill' then 'Jones' else '' end";
  public void testMetamodelComplexConditionCaseInCriteriaUpdate() {
    if ((getPersistenceUnitServerSession()).getPlatform().isSymfoware()) {
      getPersistenceUnitServerSession()
          .logMessage(
              "Test complexConditionCaseInUpdateTest skipped for this platform, "
                  + "Symfoware doesn't support UpdateAll/DeleteAll on multi-table objects (see rfe 298193).");
      return;
    }
    EntityManager em = createEntityManager();
    List<Employee> results = null;

    Metamodel metamodel = em.getMetamodel();
    EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class);

    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaUpdate<Employee> cq = qb.createCriteriaUpdate(Employee.class);
    Root<Employee> root = cq.from(Employee.class);
    Case caseExp = qb.selectCase();
    caseExp.when(
        qb.equal(root.get(entityEmp_.getSingularAttribute("firstName", String.class)), "Bob"),
        "Jones");
    caseExp.when(
        qb.equal(root.get(entityEmp_.getSingularAttribute("firstName", String.class)), "Jill"),
        "Jones");
    caseExp.otherwise("");
    cq.set(root.get(entityEmp_.getSingularAttribute("lastName")), caseExp);

    beginTransaction(em);
    try {
      clearCache();

      em.createQuery(cq).executeUpdate();

      String verificationString = "select e from Employee e where e.lastName = 'Jones'";
      results = em.createQuery(verificationString).getResultList();
    } finally {
      if (isTransactionActive(em)) {
        rollbackTransaction(em);
      }
      closeEntityManager(em);
    }
    assertTrue("complexConditionCaseInUpdateTest - wrong number of results", results.size() == 2);
    for (Employee e : results) {
      assertTrue(
          "complexConditionCaseInUpdateTest wrong last name for - " + e.getFirstName(),
          e.getLastName().equals("Jones"));
    }
  }
Example #13
0
  @SuppressWarnings("unchecked")
  private Class<E> getResultType(EntityManager em) {
    // We support this so users don't have to specify the query return type when using @Sync.
    if (resultTypeFqcn.equals("java.lang.Object")) {
      return (Class<E>) Object.class;
    }

    for (EntityType<?> et : em.getMetamodel().getEntities()) {
      if (et.getJavaType().getName().equals(resultTypeFqcn)) {
        return ((EntityType<E>) et).getJavaType();
      }
    }

    throw new IllegalStateException(
        "Result type " + resultTypeFqcn + " is not known to the EntityManager.");
  }
Example #14
0
  public <E> Predicate byExampleOnEmbeddable(
      Path<E> embeddablePath,
      final E embeddableValue,
      SearchParameters sp,
      CriteriaBuilder builder) {
    if (embeddableValue == null) {
      return null;
    }

    Class<E> type = embeddablePath.getModel().getBindableJavaType();
    ManagedType<E> mt =
        em.getMetamodel().embeddable(type); // note: calling .managedType() does not work

    return JpaUtil.andPredicate(
        builder, byExample(mt, embeddablePath, embeddableValue, sp, builder));
  }
Example #15
0
  public <T extends Identifiable<?>> Predicate byExampleOnEntity(
      Root<T> rootPath, final T entityValue, SearchParameters sp, CriteriaBuilder builder) {
    if (entityValue == null) {
      return null;
    }

    Class<T> type = rootPath.getModel().getBindableJavaType();
    ManagedType<T> mt = em.getMetamodel().entity(type);

    List<Predicate> predicates = newArrayList();
    predicates.addAll(byExample(mt, rootPath, entityValue, sp, builder));
    predicates.addAll(byExampleOnCompositePk(rootPath, entityValue, sp, builder));
    predicates.addAll(
        byExampleOnXToOne(mt, rootPath, entityValue, sp, builder)); // 1 level deep only
    predicates.addAll(byExampleOnManyToMany(mt, rootPath, entityValue, sp, builder));
    return JpaUtil.andPredicate(builder, predicates);
  }
Example #16
0
  @Override
  public List<Pessoa> listByEntity(Pessoa pessoa) {

    CriteriaBuilder cb = manager.getCriteriaBuilder();
    CriteriaQuery<Pessoa> query = cb.createQuery(Pessoa.class);
    Root<Pessoa> root = query.from(Pessoa.class);
    EntityType<Pessoa> typePessoa = manager.getMetamodel().entity(Pessoa.class);

    Predicate where1 = null, where2 = null, where3 = null, where4 = null;

    if (pessoa.getId() != null) {
      where1 = cb.equal(root.get("id"), pessoa.getId());
    }
    if (pessoa.getDtNascimento() != null) {
      where2 = cb.equal(root.get("dtNascimento"), pessoa.getDtNascimento());
    }
    if (pessoa.getTipoPessoa() != null) {
      where3 = cb.equal(root.get("tipoPessoa"), pessoa.getTipoPessoa());
    }
    if (pessoa.getNome() != null) {
      where4 =
          cb.equal(
              root.get(typePessoa.getDeclaredSingularAttribute("nome", String.class)),
              pessoa.getNome());
    }

    List<Predicate> predicados = new ArrayList<Predicate>();
    if (where1 != null) {
      predicados.add(where1);
    }
    if (where2 != null) {
      predicados.add(where2);
    }
    if (where3 != null) {
      predicados.add(where3);
    }
    if (where4 != null) {
      predicados.add(where4);
    }

    if (predicados.size() > 0) {
      query.where(cb.or(predicados.toArray(new Predicate[] {})));
    }
    return manager.createQuery(query).getResultList();
  }
  public void run() {

    logger.debug("Starting protean server");

    if (entityManager != null) {
      for (EntityType<?> entity : entityManager.getMetamodel().getEntities()) {
        if (entity.getJavaType().getAnnotation(Protean.class) == null) {
          continue;
        }

        getEntities().put(entity.getName(), entity);
      }
    }

    Thread thread = new Thread(server);
    thread.start();
    logger.info("Started protean server");
  }
  ///// DELETE Criteria tests:
  public void simpleMetamodelCriteriaDeleteTest() {
    if ((getPersistenceUnitServerSession()).getPlatform().isSymfoware()) {
      getPersistenceUnitServerSession()
          .logMessage(
              "Test simpleDelete skipped for this platform, "
                  + "Symfoware doesn't support UpdateAll/DeleteAll on multi-table objects (see rfe 298193).");
      return;
    }
    EntityManager em = createEntityManager();
    int nrOfEmps =
        ((Number) em.createQuery("SELECT COUNT(phone) FROM PhoneNumber phone").getSingleResult())
            .intValue();

    Metamodel metamodel = em.getMetamodel();
    EntityType<PhoneNumber> entityPhone_ = metamodel.entity(PhoneNumber.class);

    // test query "Delete PhoneNumber phone";
    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaDelete<PhoneNumber> cq = qb.createCriteriaDelete(PhoneNumber.class);
    Root<PhoneNumber> root = cq.from(entityPhone_);

    beginTransaction(em);
    try {
      Query q = em.createQuery(cq);
      int updated = q.executeUpdate();
      assertEquals(
          "simpleCriteriaDeleteTest: wrong number of deleted instances" + updated,
          nrOfEmps,
          updated);

      // check database changes
      int nr =
          ((Number) em.createQuery("SELECT COUNT(phone) FROM PhoneNumber phone").getSingleResult())
              .intValue();
      assertEquals("simpleCriteriaDeleteTest: found " + nr + " employees after delete all", 0, nr);
    } finally {
      if (isTransactionActive(em)) {
        rollbackTransaction(em);
      }
      closeEntityManager(em);
    }
  }
Example #19
0
  @SuppressWarnings("unchecked")
  private static String getEntityIdField(EntityManager em, Class entity) {

    String idProperty = "";

    Metamodel metamodel = em.getMetamodel();
    EntityType e = metamodel.entity(entity);
    Set<SingularAttribute> singularAttributes = e.getSingularAttributes();

    for (SingularAttribute singularAttribute : singularAttributes) {

      if (singularAttribute.isId()) {

        idProperty = singularAttribute.getName();
        break;
      }
    }

    return idProperty;
  }
 /*
  * (non-Javadoc)
  *
  * @see org.resthub.web.controller.GenericController#update(ID, T)
  */
 @SuppressWarnings({"rawtypes", "unchecked"})
 @Override
 @PUT
 @Path("/{id}")
 public T update(@PathParam("id") ID id, T entity) {
   Assert.notNull(id, "id cannot be null");
   T retreivedEntity = this.service.findById(id);
   if (retreivedEntity == null) {
     throw new NotFoundException();
   }
   MetamodelUtils utils =
       new MetamodelUtils<T, ID>(
           (Class<T>) ClassUtils.getGenericTypeFromBean(this.service), em.getMetamodel());
   Serializable entityId = utils.getIdFromEntity(entity);
   if ((entityId != null) && !id.equals(this.getIdFromEntity(retreivedEntity))) {
     throw new WebApplicationException(Response.Status.CONFLICT);
   }
   if (null == entityId) {
     utils.setIdForEntity(entity, id);
   }
   return this.service.update(entity);
 }
Example #21
0
 @Bean
 public CacheManager cacheManager(JHipsterProperties jHipsterProperties) {
   log.debug("Starting Ehcache");
   cacheManager = net.sf.ehcache.CacheManager.create();
   cacheManager
       .getConfiguration()
       .setMaxBytesLocalHeap(jHipsterProperties.getCache().getEhcache().getMaxBytesLocalHeap());
   log.debug("Registering Ehcache Metrics gauges");
   Set<EntityType<?>> entities = entityManager.getMetamodel().getEntities();
   for (EntityType<?> entity : entities) {
     String name = entity.getName();
     if (name == null || entity.getJavaType() != null) {
       name = entity.getJavaType().getName();
     }
     Assert.notNull(name, "entity cannot exist without an identifier");
     reconfigureCache(name, jHipsterProperties);
     for (PluralAttribute pluralAttribute : entity.getPluralAttributes()) {
       reconfigureCache(name + "." + pluralAttribute.getName(), jHipsterProperties);
     }
   }
   EhCacheCacheManager ehCacheManager = new EhCacheCacheManager();
   ehCacheManager.setCacheManager(cacheManager);
   return ehCacheManager;
 }
 @PersistenceContext
 public void setEntityManager(EntityManager entityManager) {
   this.entityManager = entityManager;
   this.metamodel = entityManager.getMetamodel();
 }
 public Metamodel getMetamodel() {
   return delegate.getMetamodel();
 }
Example #24
0
 private void initialiseMetaModel() {
   if (metaModele == null) {
     metaModele = entityManager.getMetamodel();
   }
 }
  public void testMetamodelCriteriaUpdateEmbeddedField() {
    if ((getPersistenceUnitServerSession()).getPlatform().isSymfoware()) {
      getPersistenceUnitServerSession()
          .logMessage(
              "Test updateEmbeddedFieldTest skipped for this platform, "
                  + "Symfoware doesn't support UpdateAll/DeleteAll on multi-table objects (see rfe 298193).");
      return;
    }

    EntityManager em = createEntityManager();
    int nrOfEmps =
        ((Number)
                em.createQuery("SELECT COUNT(e) FROM Employee e where e.firstName is not null")
                    .getSingleResult())
            .intValue();

    Metamodel metamodel = em.getMetamodel();
    EntityType<Employee> entityEmp_ = metamodel.entity(Employee.class);
    javax.persistence.metamodel.EmbeddableType<EmploymentPeriod> embedEmpPeriod_ =
        metamodel.embeddable(EmploymentPeriod.class);

    Calendar startCalendar = Calendar.getInstance();
    startCalendar.set(1905, 11, 31, 0, 0, 0);
    java.sql.Date startDate = new java.sql.Date(startCalendar.getTime().getTime());

    // em.createQuery("UPDATE Employee e SET e.period.startDate=
    // :startDate").setParameter("startDate", startDate).executeUpdate();
    CriteriaBuilder qb = em.getCriteriaBuilder();
    CriteriaUpdate<Employee> cq = qb.createCriteriaUpdate(Employee.class);
    Root<Employee> root = cq.from(entityEmp_);
    cq.set(
        root.get(entityEmp_.getSingularAttribute("period", EmploymentPeriod.class))
            .get(embedEmpPeriod_.getSingularAttribute("startDate", java.sql.Date.class)),
        startDate);

    beginTransaction(em);
    try {
      clearCache();

      int updated = em.createQuery(cq).executeUpdate();
      assertEquals(
          "testCriteriaUpdateEmbeddedField: wrong number of updated instances", nrOfEmps, updated);

      // check database changes
      int nr =
          ((Number)
                  em.createQuery(
                          "SELECT COUNT(e) FROM Employee e WHERE e.period.startDate = :startDate")
                      .setParameter("startDate", startDate)
                      .getSingleResult())
              .intValue();
      assertEquals(
          "testCriteriaUpdateEmbeddedField: unexpected number of changed values in the database",
          nrOfEmps,
          nr);
    } finally {
      if (isTransactionActive(em)) {
        rollbackTransaction(em);
      }
      closeEntityManager(em);
    }
  }
 @Override
 public Metamodel getMetamodel() {
   // TODO Auto-generated method stub
   return myEntityManager.getMetamodel();
 }
Example #27
0
 protected static String getEntityName(Class<?> clazz, EntityManager entityManager) {
   EntityType et = entityManager.getMetamodel().entity(clazz);
   return et.getName();
 }