Merge pull request #94 from k-r-g/useAffectedRows

Optionally skip updating methodValueCache/listeners when nothing updated

Author: msmith-techempower

gemini/src/main/java/com/techempower/cache/CacheGroup.java

@@ -241,7 +241,7 @@ public TLongObjectMap<T> map()
    * Add an object to the cache and the data store.
    */
   @Override
-  public void put(T object)
+  public int put(T object)
   {
     if (readOnly())
     {
@@ -255,7 +255,7 @@ public void put(T object)
     final boolean persisted = isPersisted(object);
 
     // Persist the object.
-    putPersistent(object);
+    int rowsUpdated = putPersistent(object);
 
     if (persisted)
     {
@@ -268,6 +268,7 @@ public void put(T object)
       // Object was not persisted, so let's add it to the cache.
       addToCache(object);
     }
+    return rowsUpdated;
   }
 
   /**
@@ -278,18 +279,18 @@ public void put(T object)
    * This method is exposed as a protected class to allow subclasses to 
    * specialize the persistence behavior.  
    */
-  protected void putPersistent(T object)
+  protected int putPersistent(T object)
   {
     // Ask the EntityGroup parent to persist the changes.
-    super.put(object);
+    return super.put(object);
   }
 
   /**
    * Add objects to the cache and the data store.
    */
   @SuppressWarnings("unchecked")
   @Override
-  public void putAll(Collection<T> objectsToPut)
+  public int putAll(Collection<T> objectsToPut)
   {
     if (readOnly())
     {
@@ -315,14 +316,16 @@ public void putAll(Collection<T> objectsToPut)
     }
 
     // Persist the changes.
-    putAllPersistent(objectsToPut);
+    int rowsUpdated = putAllPersistent(objectsToPut);
 
     // Reorder any previously-persisted objects in case the field we are 
     // ordered by was changed.
     reorder(CollectionHelper.toLongArray(persisted));
 
     // Add any objects we did not previously know about.
     addToCache(nonPersisted.toArray((T[])Array.newInstance(type(), nonPersisted.size())));
+
+    return rowsUpdated;
   }
 
   /**
@@ -333,10 +336,10 @@ public void putAll(Collection<T> objectsToPut)
    * This method is exposed as a protected class to allow subclasses to 
    * specialize the persistence behavior.  
    */
-  protected void putAllPersistent(Collection<T> objectsToPut)
+  protected int putAllPersistent(Collection<T> objectsToPut)
   {
     // Ask the EntityGroup parent to persist the objects.
-    super.putAll(objectsToPut);
+    return super.putAll(objectsToPut);
   }
 
   /**

gemini/src/main/java/com/techempower/cache/EntityStore.java

@@ -104,6 +104,15 @@ public class EntityStore
   private boolean         initialized       = false;
   private boolean         cacheMethodValues = false;
 
+  /**
+   * Whether to expect the return value from Statement.executeUpdate() to indicate
+   * whether the row was actually changed. If using MySQL and the connect string
+   * has useAffectedRows=true set on it, then this can be used. It defaults to
+   * false because it is MySQL-specific and requires explicitly enabling this in
+   * the connect string.
+   */
+  private boolean         useAffectedRows   = false;
+
   /**
    * The registered method value caches.  These allow you to quickly find 
    * entities by the value of a given field.
@@ -201,6 +210,14 @@ public void configure(EnhancedProperties props)
     cacheMethodValues = props.getBoolean("CacheController.CacheMethodValues", false);
     cacheMethodValues = props.getBoolean("EntityStore.CacheMethodValues", cacheMethodValues);
 
+    // Whether to expect the return value from Statement.executeUpdate() to indicate
+    // whether the row was actually changed.
+    useAffectedRows   = props.getBoolean("EntityStore.UseAffectedRows", useAffectedRows);
+    if (useAffectedRows)
+    {
+      log.warn("EntityStore.UseAffectedRows is enabled, which REQUIRES that the database connection be configured so update statements return the count of affected rows. If unsure, disable this.");
+    }
+
     methodValueCaches = new HashMap<>();
 
     // This should only happen when the application is reconfigured.
@@ -1061,20 +1078,25 @@ public <T extends Identifiable> void put(T entity)
       throw new ControllerError("Cannot put null entity.");
     }
 
-    getGroupSafe((Class<T>)entity.getClass()).put(entity);
-    
-    // Update method value caches.
-    final MethodValueCache<?> methodValueCache = methodValueCaches.get(entity.getClass());
-    if (methodValueCache != null)
-    {
-      methodValueCache.update(entity.getId());
-    }
-    
-    // Notify the listeners.
-    final CacheListener[] toNotify = listeners;
-    for (CacheListener listener : toNotify)
+    int rowsUpdated = getGroupSafe((Class<T>)entity.getClass()).put(entity);
+
+    // If useAffectedRows is enabled, then only update the methodValueCache and
+    // notify the listeners if an actual change was persisted.
+    if (!useAffectedRows || rowsUpdated > 0)
     {
-      listener.cacheObjectExpired(entity.getClass(), entity.getId());
+      // Update method value caches.
+      final MethodValueCache<?> methodValueCache = methodValueCaches.get(entity.getClass());
+      if (methodValueCache != null)
+      {
+        methodValueCache.update(entity.getId());
+      }
+      
+      // Notify the listeners.
+      final CacheListener[] toNotify = listeners;
+      for (CacheListener listener : toNotify)
+      {
+        listener.cacheObjectExpired(entity.getClass(), entity.getId());
+      }
     }
   }
 
@@ -1631,28 +1653,33 @@ public <T extends Identifiable> void putAll(Collection<T> objects)
     {
       Class<T> type = entry.getKey();
       Collection<T> collection = entry.getValue();
-      
+
       // Update the group.
-      getGroupSafe(type).putAll(collection);
-      
-      // Update method value caches.
-      MethodValueCache<T> methodValueCache = 
-          (MethodValueCache<T>)methodValueCaches.get(type);
-      if (methodValueCache != null)
+      int rowsUpdated = getGroupSafe(type).putAll(collection);
+
+      // If useAffectedRows is enabled, then only update the methodValueCache and
+      // notify the listeners if an actual change was persisted.
+      if (!useAffectedRows || rowsUpdated > 0)
       {
-        for (T object : collection)
+        // Update method value caches.
+        MethodValueCache<T> methodValueCache = 
+            (MethodValueCache<T>)methodValueCaches.get(type);
+        if (methodValueCache != null)
         {
-          methodValueCache.update(object.getId());
+          for (T object : collection)
+          {
+            methodValueCache.update(object.getId());
+          }
         }
-      }
-      
-      // Notify the listeners.
-      final CacheListener[] toNotify = listeners;
-      for (CacheListener listener : toNotify)
-      {
-        for (T object : collection)
+        
+        // Notify the listeners.
+        final CacheListener[] toNotify = listeners;
+        for (CacheListener listener : toNotify)
         {
-          listener.cacheObjectExpired(object.getClass(), object.getId());
+          for (T object : collection)
+          {
+            listener.cacheObjectExpired(object.getClass(), object.getId());
+          }
         }
       }
     }

gemini/src/main/java/com/techempower/cache/LruCacheGroup.java

@@ -144,19 +144,27 @@ public TLongObjectMap<T> map()
   }
 
   @Override
-  public void put(T object)
+  public int put(T object)
   {
-    super.put(object);
+    int rowsUpdated = super.put(object);
     objects.put(object.getId(), object);
+    return rowsUpdated;
   }
 
   @Override
-  public void putAll(Collection<T> objectsToPut)
+  public int putAll(Collection<T> objectsToPut)
   {
+    int rowsUpdated = 0;
     for (T object : objectsToPut) 
     {
-      put(object);
+      int c = put(object);
+      if (c > 0)
+      {
+        // Only accumulate positive values;
+        rowsUpdated += c;
+      }
     }
+    return rowsUpdated;
   }
 
   @Override

gemini/src/main/java/com/techempower/cache/PureMemoryGroup.java

@@ -111,19 +111,21 @@ public static <T extends Identifiable> Builder<T> of(Class<T> type)
    * of entities.
    */
   @Override
-  protected void putPersistent(T object)
+  protected int putPersistent(T object)
   {
     // Does nothing.
+    return 0;
   }
 
   /**
    * Specialization of CacheGroup.putAllPersistent to disable the persistence
    * of entities.
    */
   @Override
-  protected void putAllPersistent(Collection<T> objects)
+  protected int putAllPersistent(Collection<T> objects)
   {
     // Does nothing.
+    return 0;
   }
 
   /**