transactional

When playing around with git , I sometimes try out things, then abort commands which take too long (e.g. some git svn commands that hang during network problems). This got me thinking: Is it always safe to forcefully abort a command (Ctrl-C or kill )? What if a command crasheds (out of memory, bug, network/FS problem)? Are repository changes "transactional" in the sense that incomplete changes are "rolled back" (like in a versioning filesystem)? Or do I risk repository corruption in that case? I'm sure the smart people working on git must have taken this into account, yet I could not find any

Well there was a point in the Grails Declarative Transactions . It said: The grails.transaction.Transactional annotation was first introduced in Grails 2.3. Prior to 2.3, Spring's @Transactional annotation was used. But I can't seem to find out what the main difference between those two annotations is. Why was the Spring's annotation not used in future releases? I would like to address this comment "However, in 2.3 the team felt it was a good idea (I disagree personally) to introduce a new annotation which could be applied not only to Services but also to Controllers.” It was never the primary

In the following piece of code (Spring 3): @Transactional("txManager") public class DaoHolder { @Transactional(value="txManager", readOnly=false, propagation=Propagation.REQUIRES_NEW, rollbackFor={Exception.class}) private void runTransactionalMethod() throws Exception { dao1.insertRow(); dao2.insertRow(); //throw new Exception(); } //... } dao1 uses a session factory attached to datasource1 dao2 uses a session factory attached to datasource2 txManager is a HibernateTransactionManager using the same session factory as dao1 The code above works correctly in a transactional manner - in

I have used this tutorial them same way in my application: http://www.benmccann.com/hibernate-with-jpa-annotations-and-guice/ My app is JAX-RS web service which will receive many concurrent requests and make updates to database. GenericDAOImpl.java implementation: public class GenericDAOImpl<T> implements GenericDAO<T> { @Inject protected EntityManager entityManager; private Class<T> type; public GenericDAOImpl(){} public GenericDAOImpl(Class<T> type) { this.type = type; } @Override public void save(T entity) { entityManager.getTransaction().begin(); entityManager.persist(entity);

I run into strange problem while developing application using Spring (3.0.5), Hibernate (3.6.0) and Wicket (1.4.14). The problem is: i cannot save or modify any object into database. By 'cannot' I mean that all changes in object or calls to EntityManager.persist(foo) are simply, silently ignored. Selects work. Sample case is simple - on some wicket page i try to save object into database, like follows public class ComicDetailsPage extends PublicBasePage { @Override protected void onConfigure() { System.out.println("In onConfigure"); super.onConfigure(); comicDAO.insert("abc"); } @SpringBean

I know right now there is no such thing as inter-step transactionality in Spring-Batch. I'm developing a complex batch job, with many steps performing several actions in database, and each one is related with the others, in such way that each one of them belongs to the same transaction. The way I understand the Spring-Batch paradigm I'm bound to use one-step job in order to have transactionality. Is there any thought (or any other way) to have some kind of job-level transactionality in lately or future versions? Edit1: I have found in this link , point 6.3.1, a way to concatenate several