public void queryMedicalHistory4() { EntityManager em = emf.createEntityManager(); Map medicals = new HashMap(); long ssn = 0; EntityTransaction tran = em.getTransaction(); tran.begin(); String jpql = "select m from MedicalHistory2 m"; Query q = em.createQuery(jpql); List<MedicalHistory2> ms = q.getResultList(); for (MedicalHistory2 m : ms) { ssn = m.getId(); } tran.commit(); em.close(); em = emf.createEntityManager(); tran = em.getTransaction(); tran.begin(); jpql = "select m from MedicalHistory2 m where m.patient.ssn = " + ssn; q = em.createQuery(jpql); ms = q.getResultList(); for (MedicalHistory2 m : ms) { assertMedicalHistory2(m); } tran.commit(); em.close(); findObj4(ssn); }
public static void main(String[] args) { // Start EntityManagerFactory EntityManagerFactory emf = Persistence.createEntityManagerFactory("black", new DBConnector().mysql); // First unit of work EntityManager em = emf.createEntityManager(); EntityTransaction tx = em.getTransaction(); tx.begin(); // Persist data MessageHibModel MessageHib = new MessageHibModel("Hello World with JPA and JTA"); em.persist(MessageHib); // Commit & close tx.commit(); em.close(); // Second unit of work EntityManager newEm = emf.createEntityManager(); EntityTransaction newTx = newEm.getTransaction(); newTx.begin(); MessageHibModel m = new MessageHibModel(); m.setText("Hello World with JPA and JTA"); @SuppressWarnings("unchecked") List<EntityManager> MessageHibs = newEm .createQuery( "select m from MessageHibModel m where m.text like :sText order by m.text asc") .setParameter("sText", m.getText()) .setFlushMode(FlushModeType.COMMIT) // .setHint("org.hibernate.cacheMode",org.hibernate.CacheMode.IGNORE) .setHint("org.hibernate.cacheable", true) .setHint("org.hibernate.readOnly", true) .setHint("org.hibernate.comment", "My Comment...") .setFirstResult(1) // .getSingleResult() .setMaxResults(20) .getResultList(); System.out.println(MessageHibs.size() + " Message(s) found:"); for (Object m1 : MessageHibs) { MessageHibModel loadedMsg = (MessageHibModel) m1; System.out.println(loadedMsg.getText()); } newTx.commit(); newEm.close(); // Shutting down the application emf.close(); }
@Test @RunOrder(5) public void deleteByEntityTest() { getForUpfate(); EntityManager em = emf.createEntityManager(); EntityTransaction transaction = em.getTransaction(); try { transaction.begin(); // ============= Query construction ============== // JpaQueryStream<Person> stream = JpaQueryProvider.delete(em, Person.class) .where() .equal(Person::getPersonalNo, PERSONAL_NO2) .and() .like(Person::getLastName, "lname%") .and() .startsWith(Person::getFirstName, "fname"); int rows = stream.execute(); // =============================================// transaction.commit(); System.out.println(); System.out.println("-------Entity----"); System.out.println(); System.out.format("deleted %s rows\n", rows); Assert.assertEquals("No expected row number was updated", rows, 1); } catch (Throwable ex) { rollback(transaction); } finally { em.close(); } }
@Override public R apply(final D input) { RuntimeException rootCause = null; for (int i = 0; i < retries; i++) { EntityTransaction db = Entities.get(this.entityType); try { R ret = this.function.apply(input); db.commit(); return ret; } catch (RuntimeException ex) { db.rollback(); if (Exceptions.isCausedBy(ex, OptimisticLockException.class)) { rootCause = Exceptions.findCause(ex, OptimisticLockException.class); } else if (Exceptions.isCausedBy(ex, LockAcquisitionException.class)) { rootCause = Exceptions.findCause(ex, LockAcquisitionException.class); } else { rootCause = ex; Logs.extreme().error(ex, ex); throw ex; } try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException ex1) { Exceptions.maybeInterrupted(ex1); } continue; } } throw (rootCause != null ? rootCause : new NullPointerException( "BUG: Transaction retry failed but root cause exception is unknown!")); }
public User editUser(Long userId, String password, long bitmap) { if (password.isEmpty()) { return null; } Privileges privileges = new Privileges(bitmap); EntityTransaction transaction = startSaveTransaction(); User user = getUserById(userId); if (user != null) { user.setPassword(password); user.setCategoryRead(privileges.isCategoryRead()); user.setCategoryWrite(privileges.isCategoryWrite()); user.setCategoryDelete(privileges.isCategoryDelete()); user.setItemRead(privileges.isItemRead()); user.setItemWrite(privileges.isItemWrite()); user.setItemDelete(privileges.isItemDelete()); user.setItemCommentRead(privileges.isItemCommentRead()); user.setItemCommentWrite(privileges.isItemCommentWrite()); user.setItemCommentDelete(privileges.isItemCommentDelete()); user.setUserPromote(privileges.isUserPromote()); user.setUserDemote(privileges.isUserDemote()); user.setUserDelete(privileges.isUserDelete()); } try { entityManager.persist(user); transaction.commit(); return user; } catch (Exception e) { transaction.rollback(); } return null; }
public Category editCategory( Long categoryId, String name, String description, String overpassKeyValue, User updateUser) { if (updateUser == null || !updateUser.isCategoryWrite() || name.isEmpty()) { return null; } EntityTransaction transaction = startSaveTransaction(); Category category = getCategoryById(categoryId); if (category != null) { category.setName(name); category.setDescription(description); category.setOverpassKeyValue(overpassKeyValue); category.setUpdateUser(updateUser); category.setUpdateTimestamp(new Timestamp(new Date().getTime())); } try { entityManager.persist(category); transaction.commit(); return category; } catch (Exception e) { transaction.rollback(); } return null; }
public Item editItem( Long itemId, String title, String description, BigDecimal price, Long categoryId, User updateUser) { if (updateUser == null || !updateUser.isItemWrite() || title.isEmpty() || price == null) { return null; } EntityTransaction transaction = startSaveTransaction(); Item item = getItem(itemId); if (item != null) { item.setTitle(title); item.setDescription(description); item.setPrice(price); item.setCategory(getCategoryById(categoryId)); item.setUpdateUser(updateUser); item.setUpdateTimestamp(new Timestamp(new Date().getTime())); } try { entityManager.persist(item); transaction.commit(); return item; } catch (Exception e) { transaction.rollback(); } return null; }
public InterestRate getInterestRateByInterestRateId(String interestRateId) { // Obtains entity manager object EntityManager entityManager = EntityManagerFactoryUtil.createEntityManager(); // Obtains transaction from entity manager EntityTransaction entr = entityManager.getTransaction(); // -----------Begin transaction----------- InterestRate interestRate = null; try { entr.begin(); // Get a list of accounts from DB TypedQuery<InterestRate> query = entityManager.createQuery( "SELECT i FROM " + InterestRate.class.getName() + " i where i.interestRateId = ?", InterestRate.class); query.setParameter(1, Integer.parseInt(interestRateId)); interestRate = query.getSingleResult(); entr.commit(); } catch (Exception e) { entityManager.close(); } // -----------End transaction----------- return interestRate; }
public void modificar(Estado c) { EntityManager em = FactoryDAO.em; EntityTransaction etx = em.getTransaction(); etx.begin(); em.merge(c); etx.commit(); }
private void withBatch() { int entityCount = 100; // tag::batch-session-batch-insert-example[] EntityManager entityManager = null; EntityTransaction txn = null; try { entityManager = entityManagerFactory().createEntityManager(); txn = entityManager.getTransaction(); txn.begin(); int batchSize = 25; for (int i = 0; i < entityCount; ++i) { Person Person = new Person(String.format("Person %d", i)); entityManager.persist(Person); if (i % batchSize == 0) { // flush a batch of inserts and release memory entityManager.flush(); entityManager.clear(); } } txn.commit(); } catch (RuntimeException e) { if (txn != null && txn.isActive()) txn.rollback(); throw e; } finally { if (entityManager != null) { entityManager.close(); } } // end::batch-session-batch-insert-example[] }
private void withoutBatch() { // tag::batch-session-batch-example[] EntityManager entityManager = null; EntityTransaction txn = null; try { entityManager = entityManagerFactory().createEntityManager(); txn = entityManager.getTransaction(); txn.begin(); for (int i = 0; i < 100_000; i++) { Person Person = new Person(String.format("Person %d", i)); entityManager.persist(Person); } txn.commit(); } catch (RuntimeException e) { if (txn != null && txn.isActive()) txn.rollback(); throw e; } finally { if (entityManager != null) { entityManager.close(); } } // end::batch-session-batch-example[] }
/** * Retrieve a task list for the user. Tasks are retrieved from the storage for the user performing * the request. * * @return A list of tasks */ private List<Task> retrieveTaskList() { List<Task> lstTasks = new LinkedList<>(); EntityManager em = getEntityManager(); EntityTransaction et = null; List<Object[]> taskList = null; try { et = em.getTransaction(); et.begin(); taskList = em.createNamedQuery("tasks.userAll").setParameter("user", getUser()).getResultList(); et.commit(); } catch (RuntimeException re) { if (et != null && et.isActive()) { et.rollback(); } log.error("Impossible to retrieve the task list"); log.error(re); throw new RuntimeException("Impossible to access the task list"); } finally { em.close(); } if (taskList != null && !taskList.isEmpty()) { for (Object[] elem : taskList) { int idElem = 0; Task tmpTask = new Task(); tmpTask.setId((String) elem[idElem++]); tmpTask.setDescription((String) elem[idElem++]); tmpTask.setState((Task.STATE) elem[idElem++]); tmpTask.setDateCreated((Date) elem[idElem]); lstTasks.add(tmpTask); } } return lstTasks; }
/** * Updates or adds an agent to the database. * * @param agent The Agent you wish to modify or add in the database. */ protected void updateAgentInDatabase(AgentImpl agent) { EntityManager em = null; EntityTransaction tx = null; try { em = emf.createEntityManager(); tx = em.getTransaction(); tx.begin(); AgentImpl existing = getAgent(agent.getName(), agent.getOrganization(), em); if (existing == null) { em.persist(agent); } else { existing.setConfiguration(agent.getConfiguration()); existing.setLastHeardFrom(agent.getLastHeardFrom()); existing.setState(agent.getState()); existing.setSchedulerRoles(agent.getSchedulerRoles()); existing.setUrl(agent.getUrl()); em.merge(existing); } tx.commit(); } catch (RollbackException e) { logger.warn("Unable to commit to DB in updateAgent."); throw e; } finally { if (em != null) em.close(); } }
@AroundInvoke public Object invoke(InvocationContext context) throws Exception { EntityTransaction trx = manager.getTransaction(); boolean criador = false; try { if (!trx.isActive()) { // truque para fazer rollback no que já passou // (senão, um futuro commit, confirmaria até mesmo operações sem transação) trx.begin(); trx.rollback(); // agora sim inicia a transação trx.begin(); criador = true; } return context.proceed(); } catch (Exception e) { if (trx != null && criador) { trx.rollback(); } throw e; } finally { if (trx != null && trx.isActive() && criador) { trx.commit(); } } }
public static void create(Localidad localidad) { EntityManager entityManager = PersistenceManager.getEntityManager(); EntityTransaction tr = entityManager.getTransaction(); tr.begin(); try { entityManager.persist(localidad); tr.commit(); System.out.println( "Creación de localidad:" + localidad.getNombre() + ", de la prov: " + localidad.getProvincia().getNombre() + " exitosa"); } catch (Exception ex) { tr.rollback(); System.err.println( "Error en LibroDAO.create" + "(" + Thread.currentThread().getStackTrace()[1].getLineNumber() + "):" + ex.getLocalizedMessage()); } finally { entityManager.close(); } }
/** * Remove launch permissions. * * @param accountIds */ public void removePermissions(final List<String> accountIds) { final EntityTransaction db = Entities.get(ImageInfo.class); try { final ImageInfo entity = Entities.merge(this); Iterables.all( accountIds, new Predicate<String>() { @Override public boolean apply(final String input) { try { final Account account = Accounts.lookupAccountById(input); ImageInfo.this.getPermissions().remove(input); } catch (final Exception e) { LOG.error(e, e); } return true; } }); db.commit(); } catch (final Exception ex) { Logs.exhaust().error(ex, ex); db.rollback(); } }
public void guardar(Estado c) { EntityManager em = FactoryDAO.em; EntityTransaction etx = em.getTransaction(); etx.begin(); em.persist(c); etx.commit(); }
// cr�ation d'objets public static void test1() throws ParseException { // contexte de persistance EntityManager em = getEntityManager(); // cr�ation personnes p1 = new Personne( "Martin", "Paul", new SimpleDateFormat("dd/MM/yy").parse("31/01/2000"), true, 2); p2 = new Personne( "Durant", "Sylvie", new SimpleDateFormat("dd/MM/yy").parse("05/07/2001"), false, 0); // cr�ation adresses a1 = new Adresse("8 rue Boileau", null, null, "49000", "Angers", null, "France"); a2 = new Adresse("Apt 100", "Les Mimosas", "15 av Foch", "49002", "Angers", "03", "France"); a3 = new Adresse("x", "x", "x", "x", "x", "x", "x"); a4 = new Adresse("y", "y", "y", "y", "y", "y", "y"); // associations personne <--> adresse p1.setAdresse(a1); p2.setAdresse(a2); // d�but transaction EntityTransaction tx = em.getTransaction(); tx.begin(); // persistance des personnes em.persist(p1); em.persist(p2); // et des adresses a3 et a4 non li�es � des personnes em.persist(a3); em.persist(a4); // fin transaction tx.commit(); // on affiche les tables dumpPersonne(); dumpAdresse(); }
public List<InterestRate> getInterestRates() { // Obtains entity manager object EntityManager entityManager = EntityManagerFactoryUtil.createEntityManager(); // Obtains transaction from entity manager EntityTransaction entr = entityManager.getTransaction(); // -----------Begin transaction----------- List<InterestRate> interestRates = null; try { entr.begin(); // Get a list of accounts from DB TypedQuery<InterestRate> query = entityManager.createQuery( "SELECT i FROM " + InterestRate.class.getName() + " i", InterestRate.class); interestRates = query.getResultList(); entr.commit(); } catch (Exception e) { entityManager.close(); } // -----------End transaction----------- return interestRates; }
public static void main(String[] args) { try { EntityManagerFactory f = Persistence.createEntityManagerFactory("DemoPU"); EntityManager manager = f.createEntityManager(); Scanner in = new Scanner(System.in); System.out.print("Enter id to modify"); int id = in.nextInt(); in.nextLine(); Emp e = manager.find(Emp.class, id); System.out.println("current details are"); System.out.println(e.getEname() + "\t" + e.getJob() + "\t" + e.getSalary()); System.out.println("Enter name to update"); String n = in.nextLine(); System.out.println("Enter job to update"); String j = in.nextLine(); System.out.println("Enter salary to update"); int s = in.nextInt(); EntityTransaction t = manager.getTransaction(); t.begin(); e.setEname(n); e.setJob(j); e.setSalary(s); t.commit(); manager.close(); System.out.println("updated"); } catch (Exception e) { System.out.println(e); } }
/** Test of an SQL query using a result set mapping giving two entities (Login + LoginAccount). */ public void testSQLResult() { if (vendorID == null) { return; } try { EntityManager em = getEM(); EntityTransaction tx = em.getTransaction(); try { tx.begin(); LoginAccount acct = new LoginAccount(1, "Fred", "Flintstone"); Login login = new Login("flintstone", "pwd"); acct.setLogin(login); em.persist(login); em.persist(acct); tx.commit(); } finally { if (tx.isActive()) { tx.rollback(); } em.close(); } em = getEM(); tx = em.getTransaction(); try { tx.begin(); // Check the results List result = em.createNativeQuery( "SELECT P.ID, P.FIRSTNAME, P.LASTNAME, P.LOGIN_ID, L.ID, L.USERNAME, L.PASSWORD " + "FROM JPA_AN_LOGINACCOUNT P, JPA_AN_LOGIN L", "AN_LOGIN_PLUS_ACCOUNT") .getResultList(); assertEquals(1, result.size()); Iterator iter = result.iterator(); while (iter.hasNext()) { // Should be a String (type of "ID" column) Object[] obj = (Object[]) iter.next(); assertEquals("Fred", ((LoginAccount) obj[0]).getFirstName()); assertEquals("flintstone", ((Login) obj[1]).getUserName()); assertEquals("Fred", ((LoginAccount) obj[0]).getFirstName()); assertTrue(((LoginAccount) obj[0]).getLogin() == ((Login) obj[1])); } tx.rollback(); } finally { if (tx.isActive()) { tx.rollback(); } em.close(); } } finally { clean(LoginAccount.class); clean(Login.class); } }
@Override public boolean apply(@Nullable Class aClass) { EntityTransaction tran = Entities.get(AccountEntity.class); try { List<AccountEntity> accounts = Entities.query(new AccountEntity()); if (accounts != null && accounts.size() > 0) { for (AccountEntity account : accounts) { if (account.getCanonicalId() == null || account.getCanonicalId().equals("")) { account.setCanonicalId(genCanonicalId()); LOG.debug( "putting canonical id " + account.getCanonicalId() + " on account " + account.getAccountNumber()); } } } tran.commit(); } catch (Exception ex) { tran.rollback(); LOG.error( "caught exception during upgrade, while attempting to generate and assign canonical ids"); Exceptions.toUndeclared(ex); } return true; }
public ItemComment editItemComment( Long itemCommentId, String text, Integer rating, User updateUser) { if (updateUser == null || !updateUser.isItemCommentWrite() || text.isEmpty() || rating == null) { return null; } EntityTransaction transaction = startSaveTransaction(); ItemComment itemComment = getItemComment(itemCommentId); if (itemComment != null) { itemComment.setText(text); itemComment.setRating(correctRating(rating)); itemComment.setUpdateUser(updateUser); itemComment.setUpdateTimestamp(new Timestamp(new Date().getTime())); } try { entityManager.persist(itemComment); transaction.commit(); return itemComment; } catch (Exception e) { transaction.rollback(); } return null; }
public void updateContact(Contact cn, String id) { EntityTransaction et = em.getTransaction(); et.begin(); Query query = em.createQuery("UPDATE c from Contact c WHERE c.id=" + id); query.executeUpdate(); et.commit(); }
public User createUser(String username, String password, long bitmap) { if (username.isEmpty() || password.isEmpty()) { return null; } Privileges privileges = new Privileges(bitmap); EntityTransaction transaction = startSaveTransaction(); User user = new User( username, password, privileges.isCategoryRead(), privileges.isCategoryWrite(), privileges.isCategoryDelete(), privileges.isItemRead(), privileges.isItemWrite(), privileges.isItemDelete(), privileges.isItemCommentRead(), privileges.isItemCommentWrite(), privileges.isItemCommentDelete(), privileges.isUserPromote(), privileges.isUserDemote(), privileges.isUserDelete()); try { entityManager.persist(user); transaction.commit(); return user; } catch (Exception e) { transaction.rollback(); } return null; }
@Override public void delete(Object instance) { EntityTransaction tx = manager.getTransaction(); tx.begin(); manager.remove(instance); tx.commit(); }
public Item createItem( String title, String description, BigDecimal price, Long categoryId, User createUser) { if (createUser == null || !createUser.isItemWrite() || title.isEmpty() || price == null || categoryId == 0) { return null; } EntityTransaction transaction = startSaveTransaction(); Item item = new Item(getCategoryById(categoryId), title, description, price, createUser, createUser); try { entityManager.persist(item); transaction.commit(); return item; } catch (Exception e) { transaction.rollback(); } return null; }
/** * Add launch permissions. * * @param accountIds */ public void addPermissions(final List<String> accountIds) { final EntityTransaction db = Entities.get(ImageInfo.class); try { final ImageInfo entity = Entities.merge(this); Iterables.all( accountIds, new Predicate<String>() { @Override public boolean apply(final String input) { try { final Account account = Accounts.lookupAccountById(input); ImageInfo.this.getPermissions().add(input); } catch (final Exception e) { try { final User user = Accounts.lookupUserById(input); ImageInfo.this.getPermissions().add(user.getAccount().getAccountNumber()); } catch (AuthException ex) { try { final User user = Accounts.lookupUserByAccessKeyId(input); ImageInfo.this.getPermissions().add(user.getAccount().getAccountNumber()); } catch (AuthException ex1) { LOG.error(ex1, ex1); } } } return true; } }); db.commit(); } catch (final Exception ex) { Logs.exhaust().error(ex, ex); db.rollback(); } }
void markAsBroken(ETask task, EntityManager em) { EntityTransaction et = em.getTransaction(); et.begin(); task.setStatus(ETask.statusSysError); et.commit(); }
private void getForUpfate() { EntityManager em = emf.createEntityManager(); EntityTransaction transaction = em.getTransaction(); try { JpaQueryStream<Person> stream = JpaQueryProvider.select(em, Person.class) .where() .equal(Person::getPersonalNo, PERSONAL_NO2) .and() .like(Person::getLastName, "lname%") .and() .startsWith(Person::getFirstName, "fname"); Person person = stream.getFirst(); transaction.begin(); if (person == null) { Person newPerson = QueryTest.initPerson(); em.persist(newPerson); person = newPerson; } transaction.commit(); } catch (Throwable ex) { rollback(transaction); } finally { em.close(); } }