Optionally skip updating methodValueCache/listeners when nothing updated

When useAffectedRows is available, use that to determine whether put()
actually affected rows in the database. If not, don't bother updating the
methodValueCache or notifying the listeners.

This is most valuable as a way to avoid sending pointless JMS messages via
CacheMessageManager.

Author: Keith R. Gustafson

Diff for: 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);
   }
 
   /**

Diff for: 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());
+          }
         }
       }
     }

Diff for: 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

Diff for: 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;
   }
 
   /**