Merged fix for GRAILS-5277 "Grails still flushes the session after an action

completes when an exception is caught and not rethrown"
Also fixes GRAILS-4776

Author: graemerocher

src/groovy/org/codehaus/groovy/grails/plugins/orm/hibernate/HibernatePluginSupport.groovy

@@ -55,6 +55,9 @@ import org.hibernate.proxy.LazyInitializer
 import org.apache.commons.beanutils.PropertyUtils
 import org.hibernate.Hibernate
 import org.springframework.validation.Validator
+import org.springframework.dao.DataAccessException
+import org.hibernate.FlushMode
+import org.codehaus.groovy.grails.commons.ConfigurationHolder
 
 
 /**
@@ -694,15 +697,29 @@ Try using Grails' default cache provider: 'org.hibernate.cache.OSCacheProvider'"
 
         metaClass.delete = {->
             def obj = delegate
-            template.execute({Session session ->
-                session.delete obj
-            } as HibernateCallback)
+            try {
+                template.execute({Session session ->
+                    session.delete obj
+                    if(this.shouldFlush()) {
+                        session.flush()
+                    }
+                } as HibernateCallback)
+            }
+            catch (DataAccessException e) {
+                handleDataAccessException(template, e)
+            }
         }
         metaClass.delete = { Map args ->
             def obj = delegate
             template.delete obj
-            if(args?.flush)
-                template.flush()
+            if(shouldFlush(args)) {
+                try {
+                    template.flush()
+                }
+                catch (DataAccessException e) {
+                    handleDataAccessException(template, e)
+                }
+            }
         }
         metaClass.refresh = {-> template.refresh(delegate); delegate }
         metaClass.discard = {->template.evict(delegate); delegate }
@@ -743,6 +760,32 @@ Try using Grails' default cache provider: 'org.hibernate.cache.OSCacheProvider'"
         }
     }
 
+    static shouldFlush(Map map = [:]) {
+        def shouldFlush
+
+        if(map?.containsKey('flush')) {
+            shouldFlush = Boolean.TRUE == map.flush
+        } else {
+            def config = ConfigurationHolder.flatConfig
+            shouldFlush = Boolean.TRUE == config?.get('grails.gorm.autoFlush')
+        }
+        return shouldFlush
+    }
+    /**
+      * Session should no longer be flushed after a data access exception occurs (such a constriant violation)
+      */
+     static void handleDataAccessException(HibernateTemplate template, DataAccessException e) {
+         try {
+             template.execute({Session session ->
+                 session.setFlushMode(FlushMode.MANUAL)
+             } as HibernateCallback)
+         }
+         finally {
+             throw e
+         }
+     }
+    
+
     private static convertToType(value, targetType) {
         SimpleTypeConverter typeConverter = new SimpleTypeConverter()
 

src/persistence/org/codehaus/groovy/grails/orm/hibernate/metaclass/SavePersistentMethod.java

@@ -19,6 +19,7 @@
 import org.hibernate.HibernateException;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
+import org.springframework.dao.DataAccessException;
 import org.springframework.orm.hibernate3.HibernateCallback;
 import org.springframework.orm.hibernate3.HibernateTemplate;
 
@@ -52,8 +53,16 @@ protected Object performSave(final Object target, final boolean flush) {
         return ht.execute(new HibernateCallback() {
             public Object doInHibernate(Session session) throws HibernateException, SQLException {
                 session.saveOrUpdate(target);
-                if(flush)
-                    getHibernateTemplate().flush();
+                if(flush) {
+                    try {
+                        getHibernateTemplate().flush();
+                    }
+                    catch (DataAccessException e) {
+                        // session should not be flushed again after a data acccess exception!
+                        getHibernateTemplate().setFlushMode(HibernateTemplate.FLUSH_NEVER);
+                        throw e;
+                    }
+                }
                 return target;
             }
         });
@@ -64,8 +73,17 @@ protected Object performInsert(final Object target, final boolean shouldFlush) {
         return ht.execute(new HibernateCallback() {
             public Object doInHibernate(Session session) throws HibernateException, SQLException {
                 session.save(target);
-                if(shouldFlush)
-                    getHibernateTemplate().flush();
+                if(shouldFlush) {
+
+                    try {
+                        getHibernateTemplate().flush();
+                    }
+                    catch (DataAccessException e) {
+                        // session should not be flushed again after a data acccess exception!
+                        getHibernateTemplate().setFlushMode(HibernateTemplate.FLUSH_NEVER);
+                        throw e;
+                    }
+                }
                 return target;
             }
         });

test/groovy/org/codehaus/groovy/grails/orm/hibernate/DontFlushAfterDataAccessExceptionTests.groovy

@@ -0,0 +1,63 @@
+package org.codehaus.groovy.grails.orm.hibernate
+
+import org.hibernate.FlushMode
+import org.springframework.dao.DataAccessException
+
+/**
+ * @author Graeme Rocher
+ * @since 1.1
+ */
+
+public class DontFlushAfterDataAccessExceptionTests extends AbstractGrailsHibernateTests{
+
+    protected void onSetUp() {
+        gcl.parseClass('''
+import grails.persistence.*
+
+@Entity
+class DontFlushAfterDataAccessExceptionAuthor {
+
+   static hasMany = [books: DontFlushAfterDataAccessExceptionBook]
+
+   String name
+
+   static mapping = {
+       columns {
+           books cascade: 'save-update'
+       }
+   }
+}
+
+@Entity
+class DontFlushAfterDataAccessExceptionBook {
+
+   static belongsTo = [author: DontFlushAfterDataAccessExceptionAuthor]
+
+   String name
+}
+''')
+    }
+
+
+    void testDontFlushAfterDataAccessException() {
+        def Author = ga.getDomainClass("DontFlushAfterDataAccessExceptionAuthor").clazz
+
+        session.setFlushMode(FlushMode.AUTO)
+        assert Author.newInstance(name:"bob")
+                      .addToBooks(name:"my story")
+                      .save(flush:true)
+
+        assert session.getFlushMode() == FlushMode.AUTO : "should be a flush mode of auto"
+
+        session.clear()
+
+        def author = Author.get(1)
+
+        shouldFail(DataAccessException) {
+            author.delete(flush:true)
+        }
+
+        assert session.getFlushMode() == FlushMode.MANUAL : "should be a flush mode of manual after exception!"
+
+    }
+}