StatelessSession session = sessionFactory.openStatelessSession(); Transaction tx = session.beginTransaction(); for ( int i=0; i<100000; i++ ) { Item item = new Item(...); session.insert(item); } tx.commit(); session.close();
@Test public void testDynamicFetch() { Session s = openSession(); s.beginTransaction(); Date now = new Date(); User me = new User( "me" ); User you = new User( "you" ); Resource yourClock = new Resource( "clock", you ); Task task = new Task( me, "clean", yourClock, now ); // :) s.save( me ); s.save( you ); s.save( yourClock ); s.save( task ); s.getTransaction().commit(); s.close(); StatelessSession ss = sessionFactory().openStatelessSession(); ss.beginTransaction(); Task taskRef = ( Task ) ss.createQuery( "from Task t join fetch t.resource join fetch t.user" ).uniqueResult(); assertTrue( taskRef != null ); assertTrue( Hibernate.isInitialized( taskRef ) ); assertTrue( Hibernate.isInitialized( taskRef.getUser() ) ); assertTrue( Hibernate.isInitialized( taskRef.getResource() ) ); assertFalse( Hibernate.isInitialized( taskRef.getResource().getOwner() ) ); ss.getTransaction().commit(); ss.close(); cleanup(); }
StatelessSession session = sessionFactory.openStatelessSession(); Transaction tx = session.beginTransaction(); ScrollableResults customers = session.getNamedQuery("GetCustomers") .scroll(ScrollMode.FORWARD_ONLY); while ( customers.next() ) { Customer customer = (Customer) customers.get(0); customer.updateStuff(...); session.update(customer); } tx.commit(); session.close();
StatelessSession session = ((Session) entityManager.getDelegate()).getSessionFactory().openStatelessSession(); Query query = session .createQuery("SELECT a FROM Address a WHERE .... ORDER BY a.id"); query.setFetchSize(Integer.valueOf(1000)); query.setReadOnly(true); query.setLockMode("a", LockMode.NONE); ScrollableResults results = query.scroll(ScrollMode.FORWARD_ONLY); while (results.next()) { Address addr = (Address) results.get(0); // Do stuff } results.close(); session.close();
return statelessSession.getNamedQuery(queryName); return statelessSession.createQuery(queryString);
statelessSession = sessionFactory.openStatelessSession(); txn = statelessSession.getTransaction(); txn.begin(); .createQuery( "select p from Person p" ) .scroll(ScrollMode.FORWARD_ONLY); Person Person = (Person) scrollableResults.get( 0 ); processPerson(Person); statelessSession.update( Person ); statelessSession.close();
session.beginTransaction(); SequenceNumber sequenceNumber = (SequenceNumber) session.get(SequenceNumber.class, p_className); session.insert(sequenceNumber); session.update(sequenceNumber); session.getTransaction().commit(); session.close();
/** * Find. * * @param query * the native fquery * @param parameterMap * the parameter map * @param maxResult * @param firstResult * @return the list */ public List findByQuery(String query, Map<Parameter, Object> parameterMap, int firstResult, int maxResult) { s = getStatelessSession(); Query q = s.createQuery(query); q.setFirstResult(firstResult); q.setMaxResults(maxResult); setParameters(parameterMap, q); return q.list(); }
public static void main(final String[] args) throws Exception { final StatelessSession session1 = HibernateUtil.getReadOnlySessionFactory().openStatelessSession(); final StatelessSession session2 = HibernateUtil.getReadWriteSessionFactory().openStatelessSession(); try { Transaction transaction1 = session1.beginTransaction(); Transaction transaction2 = session2.beginTransaction(); ErrorLogEntity entity = (ErrorLogEntity) session1.get(ErrorLogEntity.class, 1); entity.setArea("test"); session1.update(entity); session2.update(entity); transaction1.commit(); transaction2.commit(); System.out.println("Entry details: " + entity); } finally { session1.close(); session2.close(); HibernateUtil.getReadOnlySessionFactory().close(); HibernateUtil.getReadWriteSessionFactory().close(); } }
/** * Close the open session (stateful or otherwise). */ public void close() { if (statelessSession != null) { statelessSession.close(); statelessSession = null; } if (statefulSession != null) { Method close = ReflectionUtils.findMethod(Session.class, "close"); ReflectionUtils.invokeMethod(close, statefulSession); statefulSession = null; } }
// Each single thread brings resultItems from DynamoDB StatelessSession session = factory.openStatelessSession(); Transaction tx = session.beginTransaction(); for(int i = 0; i < resultItems.size(); i++) { Customer cust = new Customer(resultItems.get(i)); Long id = session.save(cust); // get the generated id // TODO: Create a list of related customer users and assign the id to all of them and then save those customer user objects in the same transaction. if(i % BATCH_SIZE == 0) { session.flush(); session.clear(); } } tx.commit(); session.close();
@Test public void testInsertWithForeignKey() { Session session = sessionFactory().openSession(); Transaction tx = session.beginTransaction(); Message msg = new Message(); final String messageId = "message_id"; msg.setId(messageId); msg.setContent("message_content"); msg.setSubject("message_subject"); session.save(msg); tx.commit(); session.close(); StatelessSession statelessSession = sessionFactory().openStatelessSession(); tx = statelessSession.beginTransaction(); MessageRecipient signature = new MessageRecipient(); signature.setId("recipient"); signature.setEmail("recipient@hibernate.org"); signature.setMessage(msg); statelessSession.insert(signature); tx.commit(); cleanup(); }
protected <T> T withStatelessSession(Function<StatelessSession, T> effect) { final StatelessSession statelessSession = sessionFactory.openStatelessSession(); try { final Transaction tx = statelessSession.beginTransaction(); try { final T result = effect.apply(statelessSession); tx.commit(); return result; } catch (Exception e) { tx.rollback(); throw e; } } finally { statelessSession.close(); } }
.append(" VALUES('").append(parentId).append("','").append(childId).append("')"); s.createSQLQuery(query.toString()).executeUpdate();
@Override public Object find(Class clazz, Object key) { s = getStatelessSession(); Object result = null; try { result = s.get(clazz, (Serializable) key); } catch (ClassCastException ccex) { log.error("Class can not be serializable, Caused by {}.", ccex); throw new KunderaException(ccex); } catch (Exception e) { log.error("Error while finding, Caused by {}. ", e); throw new KunderaException(e); } return result; }
tx = s.beginTransaction(); try id = s.insert(entity); s.update(entity); s.update(entity); log.info(e.getMessage()); tx.commit();
@Override public Serializable insert(Object entity) { return this.raw.insert(entity); }
public void deleteByColumn(String schemaName, String tableName, String columnName, Object columnValue) { StringBuffer query = new StringBuffer(); query.append("DELETE FROM ").append(getFromClause(schemaName, tableName)).append(" WHERE ").append(columnName) .append("=").append("'").append(columnValue).append("'"); s = getStatelessSession(); Transaction tx = s.beginTransaction(); s.createSQLQuery(query.toString()).executeUpdate(); tx.commit(); }