[maven-release-plugin] prepare release avaje-ebeanorm-4.0.4

deployment

pom.xml

@@ -9,7 +9,7 @@
 
   <groupId>org.avaje.ebeanorm</groupId>
   <artifactId>avaje-ebeanorm</artifactId>
-  <version>4.0.3</version>
+  <version>4.0.4</version>
   <packaging>jar</packaging>
 
   <name>avaje-ebeanorm</name>
@@ -188,18 +188,7 @@
         <artifactId>avaje-ebeanorm-mavenenhancer</artifactId>
         <version>4.1.2</version>
         <executions>
-           <execution>
-            <id>main</id>
-            <phase>process-classes</phase>
-            <configuration>
-              <classSource>target/classes</classSource>
-              <packages>com.avaje.ebean.meta.**</packages>
-              <transformArgs>debug=1</transformArgs>
-            </configuration>
-            <goals>
-              <goal>enhance</goal>
-            </goals>
-          </execution>
+          <!--   Not going to enhance Model bean -->
           <execution>
             <id>test</id>
             <phase>process-test-classes</phase>
@@ -230,8 +219,29 @@
         </configuration>
       </plugin>
 
+<!--
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>2.9.1</version>
+        <configuration>
+          <doctitle>Ebean 4</doctitle>
+          <overview>src/main/java/com/avaje/ebean/overview.html</overview>
+          <excludePackageNames>com.avaje.ebeaninternal.*:com.avaje.ebean.util</excludePackageNames>
+        </configuration>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <phase>site</phase>
+            <goals>
+              <goal>aggregate</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+-->    
     </plugins>
 
   </build>
-
+ 
 </project>

src/main/java/com/avaje/ebean/Model.java

@@ -29,7 +29,7 @@ import javax.persistence.MappedSuperclass;
  * relatively nice clean way to write queries.
  */
 @MappedSuperclass
-public class Model {
+public abstract class Model {
 
   /**
    * Return the underlying 'default' EbeanServer.
@@ -38,9 +38,36 @@ public class Model {
    * This provides full access to the API such as explicit transaction demarcation etc.
    * 
    * <p>
-   * TODO: Transaction example
+   * Example:
+   * <pre class="code">
+   * Transaction transaction = Customer.db().beginTransaction();
+   * try {
+   * 
+   *   // turn off cascade persist for this transaction
+   *   transaction.setPersistCascade(false);
+   * 
+   *   // extra control over jdbc batching for this transaction
+   *   transaction.setBatchGetGeneratedKeys(false);
+   *   transaction.setBatchMode(true);
+   *   transaction.setBatchSize(20);
+   * 
+   *   Customer customer = new Customer();
+   *   customer.setName(&quot;Roberto&quot;);
+   *   customer.save();
+   * 
+   *   Customer otherCustomer = new Customer();
+   *   otherCustomer.setName(&quot;Franko&quot;);
+   *   otherCustomer.save();
+   * 
+   *   transaction.commit();
+   * 
+   * } finally {
+   *   transaction.end();
+   * }
+   * 
+   * </pre>
    */
-  public EbeanServer db() {
+  public static EbeanServer db() {
     return Ebean.getServer(null);
   }
 
@@ -54,7 +81,7 @@ public class Model {
    * @param server
    *          The name of the EbeanServer. If this is null then the default EbeanServer is returned.
    */
-  public EbeanServer db(String server) {
+  public static EbeanServer db(String server) {
     return Ebean.getServer(server);
   }
 

src/main/java/com/avaje/ebeaninternal/server/deploy/BeanDescriptorManager.java

@@ -18,6 +18,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.avaje.ebean.BackgroundExecutor;
+import com.avaje.ebean.Model;
 import com.avaje.ebean.RawSql;
 import com.avaje.ebean.RawSqlBuilder;
 import com.avaje.ebean.annotation.ConcurrencyMode;
@@ -1411,6 +1412,10 @@ public class BeanDescriptorManager implements BeanDescriptorMap {
       // we got to the top of the inheritance
       return;
     }
+    if (Model.class.equals(superclass)) {
+      // top of the inheritance. Not enhancing Model at this stage
+      return;
+    }
     if (!EntityBean.class.isAssignableFrom(superclass)) {
       throw new IllegalStateException("Super type "+superclass+" is not enhanced?");
     }

src/main/java/com/avaje/ebeaninternal/server/loadcontext/DLoadBeanContext.java

@@ -56,8 +56,9 @@ public class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContex
     if (currentBuffer.isFull()) {
       currentBuffer = createBuffer(secondaryBatchSize);      
     }
-    currentBuffer.add(ebi);
+    // set the persistenceContext on the bean first 
     ebi.setBeanLoader(0, currentBuffer, getPersistenceContext());
+    currentBuffer.add(ebi);
   }
   
 	private LoadBuffer createBuffer(int size) {
@@ -100,16 +101,13 @@ public class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContex
    */
   public static class LoadBuffer implements BeanLoader, LoadBeanBuffer {
     
-    private final PersistenceContext persistenceContext;
     private final DLoadBeanContext context;
     private final int batchSize;
     private final List<EntityBeanIntercept> list;
+    private PersistenceContext persistenceContext;
     
     public LoadBuffer(DLoadBeanContext context, int batchSize) {
       this.context = context;
-      // set the persistence context as at this moment in 
-      // case it changes as part of a findIterate etc
-      this.persistenceContext = context.getPersistenceContext();
       this.batchSize = batchSize;
       this.list = new ArrayList<EntityBeanIntercept>(batchSize);
     }
@@ -125,6 +123,10 @@ public class DLoadBeanContext extends DLoadBaseContext implements LoadBeanContex
      * Return true if the buffer is full.
      */
     public void add(EntityBeanIntercept ebi) {
+      if (persistenceContext == null) {
+        // get persistenceContext from first loaded bean into the buffer
+        persistenceContext = ebi.getPersistenceContext();
+      }
       list.add(ebi);
     }
     

src/main/java/com/avaje/ebeaninternal/server/persist/dml/DeleteHandler.java

@@ -8,7 +8,6 @@ import javax.persistence.OptimisticLockException;
 import com.avaje.ebeaninternal.api.DerivedRelationshipData;
 import com.avaje.ebeaninternal.api.SpiTransaction;
 import com.avaje.ebeaninternal.server.core.PersistRequestBean;
-import com.avaje.ebeaninternal.server.deploy.BeanProperty;
 import com.avaje.ebeaninternal.server.type.DataBind;
 
 /**

src/main/java/com/avaje/ebeaninternal/server/persist/dml/DmlHandler.java

@@ -266,10 +266,6 @@ public abstract class DmlHandler implements PersistHandler, BindableRequest {
       return stmt;
     }
 
-    if (logLevelSql) {
-      t.logSql(sql);
-    }
-
     stmt = getPstmt(t, sql, genKeys);
 
     PstmtBatch pstmtBatch = request.getPstmtBatch();

src/main/java/com/avaje/ebeaninternal/server/query/DefaultOrmQueryEngine.java

@@ -19,112 +19,107 @@ import com.avaje.ebeaninternal.server.deploy.BeanDescriptorManager;
  */
 public class DefaultOrmQueryEngine implements OrmQueryEngine {
 
-    /**
-     * Find using predicates
-     */
-    private final CQueryEngine queryEngine;
-      
-    /**
-     * Create the Finder.
-     */
-    public DefaultOrmQueryEngine(BeanDescriptorManager descMgr, CQueryEngine queryEngine) {
-   
-        this.queryEngine = queryEngine;
+  /**
+   * Find using predicates
+   */
+  private final CQueryEngine queryEngine;
+
+  /**
+   * Create the Finder.
+   */
+  public DefaultOrmQueryEngine(BeanDescriptorManager descMgr, CQueryEngine queryEngine) {
+
+    this.queryEngine = queryEngine;
+  }
+
+  /**
+   * Flushes the jdbc batch by default unless explicitly turned off on the transaction.
+   */
+  private <T> void flushJdbcBatchOnQuery(OrmQueryRequest<T> request) {
+
+    SpiTransaction t = request.getTransaction();
+    if (t.isBatchFlushOnQuery()) {
+      // before we perform a query, we need to flush any
+      // previous persist requests that are queued/batched.
+      // The query may read data affected by those requests.
+      t.flushBatch();
     }
+  }
+
+  public <T> int findRowCount(OrmQueryRequest<T> request) {
+
+    flushJdbcBatchOnQuery(request);
+    return queryEngine.findRowCount(request);
+  }
+
+  public <T> BeanIdList findIds(OrmQueryRequest<T> request) {
+
+    flushJdbcBatchOnQuery(request);
+    return queryEngine.findIds(request);
+  }
+
+  public <T> QueryIterator<T> findIterate(OrmQueryRequest<T> request) {
+
+    // LIMITATION: You can not use QueryIterator to load bean cache
+
+    flushJdbcBatchOnQuery(request);
+    return queryEngine.findIterate(request);
+  }
+
+  public <T> BeanCollection<T> findMany(OrmQueryRequest<T> request) {
+
+    flushJdbcBatchOnQuery(request);
+
+    BeanFinder<T> finder = request.getBeanFinder();
+
+    BeanCollection<T> result;
+    if (finder != null) {
+      // this bean type has its own specific finder
+      result = finder.findMany(request);
+    } else {
+      result = queryEngine.findMany(request);
+    }
+
+    SpiQuery<T> query = request.getQuery();
     
-    public <T> int findRowCount(OrmQueryRequest<T> request){
-    	
-    	return queryEngine.findRowCount(request);
+    if (query.isLoadBeanCache()) {
+      // load the individual beans into the bean cache
+      BeanDescriptor<T> descriptor = request.getBeanDescriptor();
+      Collection<T> c = result.getActualDetails();
+      for (T bean : c) {
+        descriptor.cacheBeanPutData((EntityBean) bean);
+      }
     }
 
-    public <T> BeanIdList findIds(OrmQueryRequest<T> request){
-    	
-    	return queryEngine.findIds(request);
+    if (!result.isEmpty() && query.isUseQueryCache()) {
+      // load the query result into the query cache
+      request.putToQueryCache(result);
     }
 
+    return result;
+  }
 
-    public <T> QueryIterator<T> findIterate(OrmQueryRequest<T> request) {
+  /**
+   * Find a single bean using its unique id.
+   */
+  public <T> T findId(OrmQueryRequest<T> request) {
 
-        // LIMITATION: You can not use QueryIterator to load bean cache
- 
-        SpiTransaction t = request.getTransaction();
-        
-        // before we perform a query, we need to flush any
-        // previous persist requests that are queued/batched.
-        // The query may read data affected by those requests.
-        t.flushBatch();
-        
-        return queryEngine.findIterate(request);
-    }
-    
-	public <T> BeanCollection<T> findMany(OrmQueryRequest<T> request) {
+    flushJdbcBatchOnQuery(request);
 
-        SpiQuery<T> query = request.getQuery();
-		
-    	BeanCollection<T> result = null;
- 
-        SpiTransaction t = request.getTransaction();
-        
-        // before we perform a query, we need to flush any
-        // previous persist requests that are queued/batched.
-        // The query may read data affected by those requests.
-        t.flushBatch();
+    BeanFinder<T> finder = request.getBeanFinder();
 
-        BeanFinder<T> finder = request.getBeanFinder();
-        if (finder != null) {
-            // this bean type has its own specific finder
-            result = finder.findMany(request);
-        } else {
-        	result = queryEngine.findMany(request);
-        }
-
-    	if (query.isLoadBeanCache()){
-        	// load the individual beans into the bean cache
-        	BeanDescriptor<T> descriptor = request.getBeanDescriptor();
-        	Collection<T> c  = result.getActualDetails();
-        	for (T bean : c) {
-        		descriptor.cacheBeanPutData((EntityBean)bean);
-          }
-        }
-
-    	if (!result.isEmpty() && query.isUseQueryCache()){
-        	// load the query result into the query cache
-        	request.putToQueryCache(result);        		
-    	}
-        
-        return result;
+    T result;
+    if (finder != null) {
+      result = finder.find(request);
+    } else {
+      result = queryEngine.find(request);
     }
 
-
-    /**
-     * Find a single bean using its unique id.
-     */
-	public <T> T findId(OrmQueryRequest<T> request) {
-        
-		T result = null;
-		        
-        SpiTransaction t = request.getTransaction();
-        
-        if (t.isBatchFlushOnQuery()){
-            // before we perform a query, we need to flush any
-            // previous persist requests that are queued/batched.
-            // The query may read data affected by those requests.
-        	t.flushBatch();
-        }
-        
-        BeanFinder<T> finder = request.getBeanFinder();
-        if (finder != null) {
-            result =  finder.find(request);
-        } else {
-        	result = queryEngine.find(request);
-        }
-        
-        if (result != null && request.isUseBeanCache()){
-        	request.getBeanDescriptor().cacheBeanPutData((EntityBean)result);        		
-        }
-        
-        return result;
+    if (result != null && request.isUseBeanCache()) {
+      request.getBeanDescriptor().cacheBeanPutData((EntityBean) result);
     }
 
+    return result;
+  }
 
 }