@Test
  public void testCascadeFromDetachedToNonDirtyRepresentations() {
    Item item1 = new Item();
    item1.setName("item1");

    Hoarder hoarder = new Hoarder();
    hoarder.setName("joe");

    Session s = openSession();
    Transaction tx = session.beginTransaction();
    s.persist(item1);
    s.persist(hoarder);
    tx.commit();
    s.close();

    // Get another representation of the same Item from a different session.

    s = openSession();
    Item item1_1 = (Item) s.get(Item.class, item1.getId());
    s.close();

    // item1_1 and item1_2 are unmodified representations of the same persistent entity.
    assertFalse(item1 == item1_1);
    assertTrue(item1.equals(item1_1));

    // Update hoarder (detached) to references both representations.
    hoarder.getItems().add(item1);
    hoarder.setFavoriteItem(item1_1);

    s = openSession();
    tx = s.beginTransaction();
    hoarder = (Hoarder) s.merge(hoarder);
    assertEquals(1, hoarder.getItems().size());
    assertSame(hoarder.getFavoriteItem(), hoarder.getItems().iterator().next());
    assertEquals(item1.getId(), hoarder.getFavoriteItem().getId());
    assertEquals(item1.getCategory(), hoarder.getFavoriteItem().getCategory());
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    hoarder = (Hoarder) s.merge(hoarder);
    assertEquals(1, hoarder.getItems().size());
    assertSame(hoarder.getFavoriteItem(), hoarder.getItems().iterator().next());
    assertEquals(item1.getId(), hoarder.getFavoriteItem().getId());
    assertEquals(item1.getCategory(), hoarder.getFavoriteItem().getCategory());
    tx.commit();
    s.close();

    cleanup();
  }
  @Transactional(value = "transactionManager")
  public DatosCancion guardar(DatosCancion datos) {
    Session session = sessionFactory.getCurrentSession();
    datos = (DatosCancion) session.merge(datos);

    return datos;
  }
Exemplo n.º 3
0
  @Override
  public Almacen actualiza(Almacen almacen, Usuario usuario) {
    Session session = currentSession();
    if (usuario != null) {
      almacen.setEmpresa(usuario.getEmpresa());
    }
    try {
      // Actualiza la almacen
      log.debug("Actualizando almacen");
      session.update(almacen);
      session.flush();

    } catch (NonUniqueObjectException e) {
      try {
        session.merge(almacen);
      } catch (Exception ex) {
        log.error("No se pudo actualizar la almacen", ex);
        throw new RuntimeException("No se pudo actualizar la almacen", ex);
      }
    }
    if (usuario != null) {
      usuario.setAlmacen(almacen);
    }
    session.flush();
    return almacen;
  }
 public void update(Dataset dataset, org.hibernate.Session hibernateSession) {
   hibernateSession.merge(dataset);
   sessionResource.publish(
       sessionId.toString(),
       new SessionEvent(sessionId, ResourceType.DATASET, dataset.getDatasetId(), EventType.UPDATE),
       hibernateSession);
 }
Exemplo n.º 5
0
 /**
  * Merges the given {@link com.yammer.maestro.models.Log}.
  *
  * @param entity the entity to merge
  * @return the persistent entity
  */
 public Log merge(Log entity) throws HibernateException {
   Log log = null;
   boolean ownsSession = false;
   Session session = null;
   Transaction txn = null;
   try {
     session = currentSession();
   } catch (HibernateException ex) {
     session = sessionFactory.openSession();
     txn = session.beginTransaction();
     ownsSession = true;
   }
   try {
     log = (Log) session.merge(entity);
   } catch (Exception ex) {
     if (ownsSession) {
       txn.rollback();
     }
   } finally {
     if (ownsSession) {
       txn.commit();
       session.close();
     }
   }
   return log;
 }
Exemplo n.º 6
0
  public Asociacion actualiza(Asociacion asociacion, Usuario usuario) {
    Session session = currentSession();
    if (usuario != null) {
      asociacion.setUnion(usuario.getAsociacion().getUnion());
    }
    try {
      // Actualiza la asociacion
      log.debug("Actualizando asociacion");
      session.update(asociacion);
      session.flush();

    } catch (NonUniqueObjectException e) {
      try {
        session.merge(asociacion);
      } catch (Exception ex) {
        log.error("No se pudo actualizar la asociacion", ex);
        throw new RuntimeException("No se pudo actualizar la asociacion", ex);
      }
    }
    if (usuario != null) {
      usuario.setAsociacion(asociacion);
    }
    session.flush();
    return asociacion;
  }
 public SelfBilledCreditNoteType merge(SelfBilledCreditNoteType value) {
   SelfBilledCreditNoteType newValue = null;
   Session session = getSession();
   newValue = (SelfBilledCreditNoteType) session.merge(value);
   if (log.isDebugEnabled()) log.debug("merging document: " + value);
   return newValue;
 }
 public LanguageCodeContentType merge(LanguageCodeContentType value) {
   LanguageCodeContentType newValue = null;
   Session session = getSession();
   newValue = (LanguageCodeContentType) session.merge(value);
   if (log.isDebugEnabled()) log.debug("merging document: " + value);
   return newValue;
 }
 public WarrantyInformationType merge(WarrantyInformationType value) {
   WarrantyInformationType newValue = null;
   Session session = getSession();
   newValue = (WarrantyInformationType) session.merge(value);
   if (log.isDebugEnabled()) log.debug("merging document: " + value);
   return newValue;
 }
 public DeliveryUnitType merge(DeliveryUnitType value) {
   DeliveryUnitType newValue = null;
   Session session = getSession();
   newValue = (DeliveryUnitType) session.merge(value);
   if (log.isDebugEnabled()) log.debug("merging document: " + value);
   return newValue;
 }
 public CorporateRegistrationSchemeType merge(CorporateRegistrationSchemeType value) {
   CorporateRegistrationSchemeType newValue = null;
   Session session = getSession();
   newValue = (CorporateRegistrationSchemeType) session.merge(value);
   if (log.isDebugEnabled()) log.debug("merging document: " + value);
   return newValue;
 }
Exemplo n.º 12
0
  @Test
  public void testBackRefToProxiedEntityOnMerge() {
    Session s = openSession();
    s.beginTransaction();
    Parent me = new Parent("Steve");
    me.getChildren().add(new Child("Joe"));
    s.persist(me);
    s.getTransaction().commit();
    s.close();

    // while detached, add a new element
    me.getChildren().add(new Child("Cece"));
    me.getChildren().add(new Child("Austin"));

    s = openSession();
    s.beginTransaction();
    // load 'me' to associate it with the new session as a proxy (this may have occurred as 'prior
    // work'
    // to the reattachment below)...
    Object meProxy = s.load(Parent.class, me.getName());
    assertFalse(Hibernate.isInitialized(meProxy));
    // now, do the reattchment...
    s.merge(me);
    s.getTransaction().commit();
    s.close();

    s = openSession();
    s.beginTransaction();
    s.createQuery("delete from Child").executeUpdate();
    s.createQuery("delete from Parent").executeUpdate();
    s.getTransaction().commit();
    s.close();
  }
 public TransportEquipmentSealType merge(TransportEquipmentSealType value) {
   TransportEquipmentSealType newValue = null;
   Session session = getSession();
   newValue = (TransportEquipmentSealType) session.merge(value);
   if (log.isDebugEnabled()) log.debug("merging document: " + value);
   return newValue;
 }
 public TargetCurrencyCodeType merge(TargetCurrencyCodeType value) {
   TargetCurrencyCodeType newValue = null;
   Session session = getSession();
   newValue = (TargetCurrencyCodeType) session.merge(value);
   if (log.isDebugEnabled()) log.debug("merging document: " + value);
   return newValue;
 }
Exemplo n.º 15
0
  /**
   * Fetch a synonym from the local cache. Failing that, create a new one.
   *
   * @param synonymType the synonym type (should be a term in the <code>genedb_synonym_type</code>
   *     CV).
   * @param synonymString the actual synonym
   * @return the cached or newly-created synonym object
   */
  public synchronized Synonym getSynonym(String synonymType, String synonymString) {
    logger.debug(String.format("Looking for synonym '%s:%s'", synonymType, synonymString));
    if (session == null) {
      throw new IllegalStateException("getSynonym called with no session");
    }

    if (synonymsByType.containsKey(synonymType, synonymString)) {
      logger.debug("Synonym found in cache");
      return synonymsByType.get(synonymType, synonymString);
    }

    if (detachedSynonymsByType.containsKey(synonymType, synonymString)) {
      logger.debug("Synonym found in detached cache. Merging");
      Synonym mergedSynonym =
          (Synonym) session.merge(detachedSynonymsByType.get(synonymType, synonymString));
      detachedSynonymsByType.remove(synonymType, synonymString);
      synonymsByType.put(synonymType, synonymString, mergedSynonym);
      return mergedSynonym;
    }

    logger.debug(String.format("Synonym '%s:%s' not found in cache", synonymType, synonymString));
    CvTerm synonymTypeCvTerm =
        (CvTerm)
            session.load(
                CvTerm.class,
                objectManager.getIdOfExistingCvTerm("genedb_synonym_type", synonymType));
    Synonym synonym = new Synonym(synonymTypeCvTerm, synonymString, synonymString);
    synonymsByType.put(synonymType, synonymString, synonym);
    return synonym;
  }
  @Test
  public void testTopLevelManyToOneManagedNestedIsDetached() {
    Item item1 = new Item();
    item1.setName("item1 name");
    Category category = new Category();
    category.setName("category");
    item1.setCategory(category);
    category.setExampleItem(item1);

    Session s = openSession();
    Transaction tx = s.beginTransaction();
    s.persist(item1);
    tx.commit();
    s.close();

    // get another representation of item1
    s = openSession();
    tx = s.beginTransaction();
    Item item1_1 = (Item) s.get(Item.class, item1.getId());
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    Item item1Merged = (Item) s.merge(item1);

    item1Merged.setCategory(category);
    category.setExampleItem(item1_1);

    // now item1Merged is managed and it has a nested detached item
    s.merge(item1Merged);
    assertEquals(category.getName(), item1Merged.getCategory().getName());
    assertSame(item1Merged, item1Merged.getCategory().getExampleItem());
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    item1 = (Item) s.get(Item.class, item1.getId());
    assertEquals(category.getName(), item1.getCategory().getName());
    assertSame(item1, item1.getCategory().getExampleItem());
    tx.commit();
    s.close();

    cleanup();
  }
Exemplo n.º 17
0
 @Test(expected = HibernateException.class)
 public void testCreateDataKO() {
   // Setup
   Person user = new Person();
   when(session.merge(user)).thenThrow(new HibernateException("fail"));
   // Action
   dao.savePerson(user);
 }
Exemplo n.º 18
0
 @Override
 @CacheEvict(value = "objectPermanent", allEntries = true)
 public GeoObject mergeUpdate(GeoObject object, boolean... forceFlush) {
   Session s = getCurrentSession();
   s.merge(object);
   flushSession(s, forceFlush);
   return object;
 }
Exemplo n.º 19
0
  public void delete(final T t) {

    final Session session = this.sessionFactory.getCurrentSession();

    t.setDeleted(true);

    session.merge(t);
  }
  @Test
  public void testTopLevelManyToOneChangedToNewEntity() {
    Item item1 = new Item();
    item1.setName("item1 name");
    Category category = new Category();
    category.setName("category");

    item1.setCategory(category);
    category.setExampleItem(item1);

    Session s = openSession();
    Transaction tx = s.beginTransaction();
    s.persist(item1);
    tx.commit();
    s.close();

    // get another representation of item1
    s = openSession();
    tx = s.beginTransaction();
    Item item1_1 = (Item) s.get(Item.class, item1.getId());
    tx.commit();
    s.close();

    // change many-to-one in top level to be a new (transient)
    Category categoryNewer = new Category();
    categoryNewer.setName("newer category");
    item1.setCategory(categoryNewer);

    // put the other representation in categoryNewer
    categoryNewer.setExampleItem(item1_1);

    s = openSession();
    tx = s.beginTransaction();
    Item item1Merged = (Item) s.merge(item1);
    // the many-to-one from the top level item will win.
    assertEquals(categoryNewer.getName(), item1Merged.getCategory().getName());
    assertSame(item1Merged, item1Merged.getCategory().getExampleItem());
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    item1 = (Item) s.get(Item.class, item1.getId());
    assertEquals(categoryNewer.getName(), item1.getCategory().getName());
    assertSame(item1, item1.getCategory().getExampleItem());
    // make sure original category is still there
    Category categoryQueried =
        (Category) s.createQuery("from Category c where c.name='category'").uniqueResult();
    assertNotNull(categoryQueried);
    // make sure original category has the same item.
    assertSame(item1, categoryQueried.getExampleItem());
    // set exampleItem to null to avoid constraint violation on cleanup.
    categoryQueried.setExampleItem(null);
    tx.commit();
    s.close();

    cleanup();
  }
Exemplo n.º 21
0
  @Override
  public void submitStockUpdate(StockItem addedItem) {
    Session session = HibernateUtil.currentSession();
    Transaction transaction = session.beginTransaction();
    session.merge(addedItem);
    transaction.commit();

    log.debug("Stock updated in db - adding stock");
  }
Exemplo n.º 22
0
 public void updateUser(User user) {
   try {
     session.beginTransaction();
     session.merge(user);
     session.getTransaction().commit();
   } catch (Exception e) {
     Logger.getLogger(UserManager.class.getName()).log(Level.INFO, "Couldn't update user", e);
   }
 }
  public void execute() {
    Session s = getFactory().openSession();
    s.beginTransaction();

    Entity entity = s.get(Entity.class, entityId);

    Assert.assertFalse(Hibernate.isPropertyInitialized(entity, "description"));
    EnhancerTestUtils.checkDirtyTracking(entity);

    Assert.assertEquals("desc", entity.getDescription());
    Assert.assertTrue(Hibernate.isPropertyInitialized(entity, "description"));

    s.getTransaction().commit();
    s.close();

    s = getFactory().openSession();
    s.beginTransaction();
    entity.setDescription("desc1");
    s.update(entity);

    // Assert.assertFalse( Hibernate.isPropertyInitialized( entity, "description" ) );
    EnhancerTestUtils.checkDirtyTracking(entity, "description");

    Assert.assertEquals("desc1", entity.getDescription());
    Assert.assertTrue(Hibernate.isPropertyInitialized(entity, "description"));

    s.getTransaction().commit();
    s.close();

    s = getFactory().openSession();
    s.beginTransaction();
    entity = s.get(Entity.class, entityId);
    Assert.assertEquals("desc1", entity.getDescription());
    s.getTransaction().commit();
    s.close();

    s = getFactory().openSession();
    s.beginTransaction();
    entity.setDescription("desc2");
    entity = (Entity) s.merge(entity);

    // Assert.assertFalse( Hibernate.isPropertyInitialized( entity, "description" ) );
    EnhancerTestUtils.checkDirtyTracking(entity, "description");

    Assert.assertEquals("desc2", entity.getDescription());
    Assert.assertTrue(Hibernate.isPropertyInitialized(entity, "description"));

    s.getTransaction().commit();
    s.close();

    s = getFactory().openSession();
    s.beginTransaction();
    entity = s.get(Entity.class, entityId);
    Assert.assertEquals("desc2", entity.getDescription());
    s.getTransaction().commit();
    s.close();
  }
Exemplo n.º 24
0
  public void update(GOI goi) {
    Session session = HibernateUtil.getSession();
    System.out.println("goi.id do aktualizacji: " + goi.getId());
    System.out.println("goi.usluga.nazwa do aktualizacji: " + goi.getUsluga().getNazwa());

    session.merge(goi);

    session.flush();
  }
  /*
   * updates customer
   *
   * @param customer to update
   */
  public void update(Student customer) {
    SessionFactory sessionFactory = HibernateSession.getSessionFactory();
    Session session = sessionFactory.openSession();
    session.beginTransaction();
    session.merge(customer);
    session.getTransaction().commit();

    session.close();
  }
  @Transactional(value = "transactionManager")
  public void guardar(List<DatosCancion> datos) {

    Session session = sessionFactory.getCurrentSession();
    for (DatosCancion dato : datos) {

      session.merge(dato);
    }
  }
Exemplo n.º 27
0
  @Test
  public void testBackRef() {
    Session s = openSession();
    Transaction t = s.beginTransaction();
    Parent p = new Parent("Marc");
    Parent p2 = new Parent("Nathalie");
    Child c = new Child("Elvira");
    Child c2 = new Child("Blase");
    p.getChildren().add(c);
    p.getChildren().add(c2);
    s.persist(p);
    s.persist(p2);
    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();
    c = (Child) s.get(Child.class, "Elvira");
    c.setAge(2);
    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();
    p = (Parent) s.get(Parent.class, "Marc");
    c = (Child) s.get(Child.class, "Elvira");
    c.setAge(18);
    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();
    p = (Parent) s.get(Parent.class, "Marc");
    p2 = (Parent) s.get(Parent.class, "Nathalie");
    c = (Child) s.get(Child.class, "Elvira");
    assertEquals(p.getChildren().indexOf(c), 0);
    p.getChildren().remove(c);
    p2.getChildren().add(c);
    t.commit();

    s.close();
    s = openSession();
    t = s.beginTransaction();
    Parent p3 = new Parent("Marion");
    p3.getChildren().add(new Child("Gavin"));
    s.merge(p3);
    t.commit();
    s.close();

    s = openSession();
    t = s.beginTransaction();
    s.createQuery("delete from Child").executeUpdate();
    s.createQuery("delete from Parent").executeUpdate();
    t.commit();
    s.close();
  }
  @Test
  @FailureExpected(jiraKey = "HHH-9239")
  public void testNestedUnidirOneToManyBackrefWithRemovedElement() {
    Item item1 = new Item();
    item1.setName("item1 name");
    SubItem subItem1 = new SubItem();
    subItem1.setName("subItem1 name");
    item1.getSubItemsBackref().add(subItem1);
    SubItem subItem2 = new SubItem();
    subItem2.setName("subItem2 name");
    item1.getSubItemsBackref().add(subItem2);

    Session s = openSession();
    Transaction tx = s.beginTransaction();
    s.persist(item1);
    tx.commit();
    s.close();

    // get another representation of item1
    s = openSession();
    tx = s.beginTransaction();
    Item item1_1 = (Item) s.get(Item.class, item1.getId());
    Hibernate.initialize(item1_1.getSubItemsBackref());
    tx.commit();
    s.close();

    // remove subItem1 from the nested Item
    item1_1.getSubItemsBackref().remove(subItem1);

    Category category = new Category();
    category.setName("category");
    item1.setCategory(category);
    category.setExampleItem(item1_1);

    s = openSession();
    tx = s.beginTransaction();
    Item item1Merged = (Item) s.merge(item1);
    // the element should have been removed
    assertEquals(1, item1Merged.getSubItemsBackref().size());
    assertTrue(item1Merged.getSubItemsBackref().contains(subItem2));
    tx.commit();
    s.close();

    s = openSession();
    tx = s.beginTransaction();
    item1 = (Item) s.get(Item.class, item1.getId());
    assertEquals(1, item1.getSubItemsBackref().size());
    assertTrue(item1.getSubItemsBackref().contains(subItem2));
    // because cascade includes "delete-orphan" the removed SubItem should have been deleted.
    subItem1 = (SubItem) s.get(SubItem.class, subItem1.getId());
    assertNull(subItem1);
    tx.commit();
    s.close();

    cleanup();
  }
Exemplo n.º 29
0
 public void update(Sample sample, Date transactionDate, Session session) throws DAOException {
   try {
     if (sample.getModifiedDate() == null) {
       sample.setModifiedDate(transactionDate);
     }
     session.merge(sample);
   } catch (Exception ex) {
     throw new DAOException(ex);
   }
 }
Exemplo n.º 30
0
 @Override
 public int update(EmployeeEntity employeeEntity) {
   Session session = sessionFactory.openSession();
   AuditEntity auditEntity = new AuditEntity();
   auditEntity.setUpdatedBy("System");
   auditEntity.setUpdatedDate(new Date());
   employeeEntity.setAuditEntity(auditEntity);
   session.merge(employeeEntity);
   return employeeEntity.getId();
 }