fix for GRAILS-398/GRAILS-674

git-svn-id: https://svn.codehaus.org/grails/trunk@2969 1cfb16fd-6d17-0410-8ff1-b7e8e1e2867d

Author: graeme

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

@@ -19,6 +19,7 @@
 
 import java.io.Serializable;
 import java.util.regex.Pattern;
+import java.sql.SQLException;
 
 import org.codehaus.groovy.grails.commons.GrailsApplication;
 import org.codehaus.groovy.grails.commons.GrailsDomainClass;
@@ -27,9 +28,13 @@
 import org.codehaus.groovy.grails.metaclass.DomainClassMethods;
 import org.codehaus.groovy.runtime.InvokerHelper;
 import org.hibernate.SessionFactory;
+import org.hibernate.Session;
+import org.hibernate.HibernateException;
+import org.hibernate.FlushMode;
 import org.springframework.beans.BeanWrapper;
 import org.springframework.beans.BeanWrapperImpl;
 import org.springframework.orm.hibernate3.HibernateTemplate;
+import org.springframework.orm.hibernate3.HibernateCallback;
 import org.springframework.validation.BindException;
 import org.springframework.validation.Errors;
 import org.springframework.validation.Validator;
@@ -124,31 +129,49 @@ private void autoRetrieveAssocations(GrailsDomainClass domainClass, Object targe
 		}
 	}
 
-	/**
-	 * Handles a validation error
-     * @return Returns null, as this represents a validation error
-     * @param target The target object being validated
+    /**
+     * This method willl set the save() method will set the flush mode to manual. What this does
+     * is ensure that the database changes are not persisted to the database if a validation error occurs.
+     * If save() is called again and validation passes the code will check if there is a manual flush mode and
+     * flush manually if necessary
+     *
+     * @param target The target object that failed validation
      * @param errors The Errors instance
+     * @return This method will return null signaling a validation failure
      */
 	protected Object handleValidationError(Object target, Errors errors) {
 		HibernateTemplate t = getHibernateTemplate();
         // if the target is within the session evict it
         // this is so that if validation fails hibernate doesn't save
         // the object automatically when the session is flushed		
-		if(t.contains(target)) {
-		    t.evict(target);
-		}        
-		if(target instanceof GroovyObject) {
-			((GroovyObject)target).setProperty(DomainClassMethods.ERRORS_PROPERTY,errors);
-		}   
-		else {
-		    DynamicMethodsMetaClass metaClass = (DynamicMethodsMetaClass)InvokerHelper.getInstance().getMetaRegistry().getMetaClass(target.getClass());
-		    metaClass.setProperty(target.getClass() ,target,DomainClassMethods.ERRORS_PROPERTY,errors, false, false);
-		}
-		return null;
+       t.execute(new HibernateCallback() {
+
+            public Object doInHibernate(Session session) throws HibernateException, SQLException {
+                session.setFlushMode(FlushMode.MANUAL);
+                return null;
+            }
+        });        
+        setErrorsOnInstance(target, errors);
+        return null;
 	}
 
-	/**
+    /**
+     * Associates the Errors object on the instance
+     *
+     * @param target The target instance
+     * @param errors The Errors object
+     */
+    protected void setErrorsOnInstance(Object target, Errors errors) {
+        if(target instanceof GroovyObject) {
+            ((GroovyObject)target).setProperty(DomainClassMethods.ERRORS_PROPERTY,errors);
+        }
+        else {
+            DynamicMethodsMetaClass metaClass = (DynamicMethodsMetaClass) InvokerHelper.getInstance().getMetaRegistry().getMetaClass(target.getClass());
+            metaClass.setProperty(target.getClass() ,target,DomainClassMethods.ERRORS_PROPERTY,errors, false, false);
+        }
+    }
+
+    /**
  	 * Checks whether validation should be performed
      * @return True if the domain class should be validated
      * @param arguments  The arguments to the validate method

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

@@ -16,10 +16,12 @@
 package org.codehaus.groovy.grails.orm.hibernate.metaclass;
 
 import java.util.regex.Pattern;
+import java.sql.SQLException;
 
 import org.codehaus.groovy.grails.commons.GrailsApplication;
-import org.hibernate.LockMode;
-import org.hibernate.SessionFactory;
+import org.hibernate.*;
+import org.springframework.orm.hibernate3.HibernateCallback;
+import org.springframework.orm.hibernate3.HibernateTemplate;
 
 /**
  * The merge() method follows the semantics of merge which attempts to "merge" an object
@@ -42,11 +44,19 @@ public MergePersistentMethod(SessionFactory sessionFactory, ClassLoader classLoa
 	/* (non-Javadoc)
 	 * @see org.codehaus.groovy.grails.orm.hibernate.metaclass.AbstractSavePersistentMethod#performSave(java.lang.Object)
 	 */
-	protected void performSave(Object target, boolean flush) {
-		getHibernateTemplate().merge(target);
-		getHibernateTemplate().lock(target, LockMode.NONE);
-		if(flush)
-			getHibernateTemplate().flush();
-	}
+	protected void performSave(final Object target, final boolean flush) {
+        HibernateTemplate ht = getHibernateTemplate();
+
+        ht.execute(new HibernateCallback() {
+            public Object doInHibernate(Session session) throws HibernateException, SQLException {
+                session.merge(target);
+                session.lock(target, LockMode.NONE);
+
+                if(flush && FlushMode.isManualFlushMode(session.getFlushMode()))
+                    getHibernateTemplate().flush();
+                return target;
+            }
+        });
+    }
 
 }

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

@@ -15,10 +15,16 @@
  */ 
 package org.codehaus.groovy.grails.orm.hibernate.metaclass;
 
-import java.util.regex.Pattern;
-
 import org.codehaus.groovy.grails.commons.GrailsApplication;
+import org.hibernate.FlushMode;
+import org.hibernate.HibernateException;
+import org.hibernate.Session;
 import org.hibernate.SessionFactory;
+import org.springframework.orm.hibernate3.HibernateCallback;
+import org.springframework.orm.hibernate3.HibernateTemplate;
+
+import java.sql.SQLException;
+import java.util.regex.Pattern;
 
 /**
  * This method follows the semantics of saveOrUpdate of scheduling the object
@@ -27,7 +33,9 @@
  * @author Steven Devijver
  * @author Graeme Rocher
  * 
- * @since Aug 7, 2005
+ * @since 0.1
+ *
+ * Created: Aug 7, 2005
  */
 public class SavePersistentMethod extends AbstractSavePersistentMethod {
 
@@ -40,10 +48,16 @@ public SavePersistentMethod(SessionFactory sessionFactory, ClassLoader classLoad
         super(METHOD_PATTERN,sessionFactory, classLoader, application);
     }
 
-	protected void performSave(Object target, boolean flush) {
-		getHibernateTemplate().saveOrUpdate(target);
-		if(flush)
-			getHibernateTemplate().flush();
+	protected void performSave(final Object target, final boolean flush) {
+        HibernateTemplate ht = getHibernateTemplate();
+        ht.execute(new HibernateCallback() {
+            public Object doInHibernate(Session session) throws HibernateException, SQLException {
+                session.saveOrUpdate(target);
+                if(flush && FlushMode.isManualFlushMode(session.getFlushMode()))
+                    getHibernateTemplate().flush();
+                return target;
+            }
+        });
 	}
-       
+
 }

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

@@ -0,0 +1,71 @@
+package org.codehaus.groovy.grails.orm.hibernate;
+
+
+import org.hibernate.FlushMode;
+
+class ValidationFailureTests extends AbstractGrailsHibernateTests {
+
+	void onSetUp() {
+		gcl.parseClass(
+"""
+class Book {
+  Long id
+  Long version
+  String title
+}
+class Author {
+    Long id
+    Long version
+    String name
+    Set books
+    static hasMany = [books: Book]
+    static constraints = {
+        name(size:8..16)
+    }
+}
+"""
+		)
+	}
+
+
+	void testValidationFailure() {
+	    def authorClass = ga.getDomainClass("Author")
+	    def bookClass = ga.getDomainClass("Book")
+
+	    def a = authorClass.newInstance()
+	    a.name = "123456789"
+
+        def b1 = bookClass.newInstance()
+        b1.title = "foo"
+	    a.addBook(b1)
+        def b2 = bookClass.newInstance()
+        b2.title = "bar"
+	    a.addBook(b2)
+
+	    a.save(true)
+
+	    assert session.contains(a)
+
+	    session.evict(a)
+	    session.evict(b1)
+	    session.evict(b2)
+	    a = null
+	    b1 = null
+	    b2 = null
+
+	    a = authorClass.clazz.get(1)
+
+	    // now invalidate a
+	    a.name = "bad"
+	    a.save()
+
+	    assertTrue FlushMode.isManualFlushMode(session.getFlushMode())
+
+	    assertEquals 2, a.books.size()
+
+    }
+	
+	void onTearDown() {
+		
+	}
+}