Bug 37315346 - [37264961->24.09.1] CQC constructor with fCacheValues of false should configure lite mapListener (ce-main-> ce-24.09)

jfialli · jfialli · commit 1d58dce3de94 · 2024-11-27T09:29:18.000-05:00
Remote remote.full on coherence-ce/release/coherence-ce-v24.09 success, changes 112626, synced @112626, job.9.20241127123943.7673 [git-p4: depot-paths = "//dev/coherence-ce/release/coherence-ce-v24.09/": change = 112634]
diff --git a/prj/coherence-core/src/main/java/com/tangosol/net/cache/ContinuousQueryCache.java b/prj/coherence-core/src/main/java/com/tangosol/net/cache/ContinuousQueryCache.java
@@ -221,7 +221,7 @@ public ContinuousQueryCache(NamedCache<K, V_BACK> cache, Filter filter,
      * @param filter        the {@link Filter} that defines the view
      * @param fCacheValues  pass {@code true} to cache both the keys and values of the
      *                      materialized view locally, or {@code false} to only cache
-     *                      the keys
+     *                      the keys. Override of {@code false} described in {@link #isCacheValues()}.
      */
     public ContinuousQueryCache(NamedCache<K, V_BACK> cache, Filter filter, boolean fCacheValues)
         {
@@ -247,7 +247,7 @@ public ContinuousQueryCache(NamedCache<K, V_BACK> cache, Filter filter, boolean
     public ContinuousQueryCache(NamedCache<K, V_BACK> cache, Filter filter,
                                 MapListener<? super K, ? super V_FRONT> listener)
         {
-        this(cache, filter, false, listener, null);
+        this(cache, filter, true, listener, null);
         }
 
     /**
@@ -284,15 +284,19 @@ public ContinuousQueryCache(NamedCache<K, V_BACK> cache, Filter filter,
      *
      * @param cache         the {@link NamedCache} to create a view of
      * @param filter        the {@link Filter} that defines the view
-     * @param fCacheValues  pass true to cache both the keys and values of the
-     *                      materialized view locally, or false to only cache
-     *                      the keys
+     * @param fCacheValues  pass {@code true} to cache both the keys and values of the
+     *                      materialized view locally, or {@code false} to only cache
+     *                      the keys. Override of {@code false} described in {@link #isCacheValues()}
      * @param listener      an optional {@link MapListener} that will receive all
      *                      events starting from the initialization of the {@code ContinuousQueryCache}
      * @param transformer   an optional {@link ValueExtractor} that would be used to
      *                      transform values retrieved from the underlying cache
      *                      before storing them locally; if specified, this
      *                      {@code ContinuousQueryCache} will become "read-only"
+     * <p>
+     * Note: When parameter {@code fCacheValues} is {@code false}, it is inferred that provided parameter
+     * {@code listener} is a lite listener as described by {@code fLite} parameter of
+     * {@link #addMapListener(MapListener, Filter, boolean)}.
      */
     public ContinuousQueryCache(NamedCache<K, V_BACK> cache, Filter filter,
                                    boolean fCacheValues, MapListener<? super K, ? super V_FRONT> listener,
@@ -321,7 +325,7 @@ public ContinuousQueryCache(NamedCache<K, V_BACK> cache, Filter filter,
      * @param filter         the {@link Filter} that defines the view
      * @param fCacheValues   pass {@code true} to cache both the keys and values of the
      *                       materialized view locally, or {@code false} to only cache
-     *                       the keys
+     *                       the keys. Override of {@code false} described in {@link #isCacheValues()}
      * @param listener       an optional {@link MapListener} that will receive all
      *                       events starting from the initialization of the
      *                       {@code ContinuousQueryCache}
@@ -330,6 +334,10 @@ public ContinuousQueryCache(NamedCache<K, V_BACK> cache, Filter filter,
      *                       before storing them locally; if specified, this
      *                       {@code ContinuousQueryCache} will become <em>read-only</em>
      * @param loader         an optional {@link ClassLoader}
+     *                            * <p>
+     * Note: When parameter {@code fCacheValues} is {@code false}, it is inferred that the provided parameter
+     * {@code listener} is a lite listener as described by {@code fLite} parameter of
+     * {@link #addMapListener(MapListener, Filter, boolean)}.
      *
      * @since 12.2.1.4
      */
@@ -365,6 +373,8 @@ public ContinuousQueryCache(Supplier<NamedCache<K, V_BACK>> supplierCache, Filte
         m_fReadOnly     = transformer != null;
         m_nState        = STATE_DISCONNECTED;
 
+        // initialize Observable listener on whether a standard (non-lite) listener passed at construction time
+        m_fListeners    = listener != null && fCacheValues;
         if (listener instanceof MapTriggerListener)
             {
             throw new IllegalArgumentException("ContinuousQueryCache does not support MapTriggerListeners");
@@ -458,13 +468,20 @@ public Filter getFilter()
 
     /**
      * Determine if this {@code ContinuousQueryCache} caches values locally.
+     * <p>
+     * Note: if {@link #addMapListener(MapListener, Filter, boolean) addMapListener} adds
+     * a standard (non-lite) listener or a filter to this {@link ObservableMap},
+     * cache values are always maintained locally. The locally cached values are
+     * used to filter events and to supply the {@link MapEvent#getOldValue() old}
+     * and {@link MapEvent#getNewValue() new} values for the events that it raises.
+     * Additionally, a non-null {@link #getTransformer() transformer} infers caches values being stored locally.
      *
      * @return {@code true} if this object caches values locally, and {@code false} if it
      *         relies on the underlying {@link NamedCache}
      */
     public boolean isCacheValues()
         {
-        return m_fCacheValues || isObserved();
+        return m_fCacheValues || isObserved() || getTransformer() != null;
         }
 
     /**
@@ -478,7 +495,7 @@ public boolean isCacheValues()
      * <p>
      *
      * @param fCacheValues  pass {@code true} to enable local caching, or {@code false}
-     *                      to disable it
+     *                      to disable it. Override of {@code false} described in {@link #isCacheValues()}.
      */
     public synchronized void setCacheValues(boolean fCacheValues)
         {
@@ -572,13 +589,13 @@ protected ObservableMap<K, V_FRONT> ensureInternalCache()
             m_mapLocal = instantiateInternalCache();
 
             MapListener mapListener = m_mapListener;
+            boolean     fLite       = !isCacheValues();
             if (mapListener != null)
                 {
                 // the initial listener has to hear the initial events
                 ensureEventQueue();
                 ensureListenerSupport().addListener(
-                        instantiateEventRouter(mapListener, false), (Filter) null, false);
-                m_fListeners = true;
+                        instantiateEventRouter(mapListener, fLite), (Filter) null, fLite);
                 }
             }
         return m_mapLocal;
@@ -1678,8 +1695,8 @@ protected synchronized void configureSynchronization(boolean fReload)
             changeState(STATE_CONFIGURING);
             m_ldtConnectionTimestamp = getSafeTimeMillis();
 
-            NamedCache cache     = getCache();
-            Filter     filter        = getFilter();
+            NamedCache cache        = getCache();
+            Filter     filter       = getFilter();
             boolean    fCacheValues = isCacheValues();
 
             // get the old filters and listeners
diff --git a/prj/test/functional/cache/src/main/java/cache/CQCTests.java b/prj/test/functional/cache/src/main/java/cache/CQCTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2023, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
  * https://oss.oracle.com/licenses/upl.
@@ -29,10 +29,13 @@
 import com.tangosol.util.InvocableMap;
 import com.tangosol.util.MapEvent;
 import com.tangosol.util.MapListener;
+import com.tangosol.util.ObservableMap;
 
 import com.tangosol.util.extractor.IdentityExtractor;
+import com.tangosol.util.extractor.KeyExtractor;
 
 import com.tangosol.util.filter.AlwaysFilter;
+import com.tangosol.util.filter.BetweenFilter;
 
 import com.tangosol.util.processor.AbstractProcessor;
 
@@ -68,8 +71,10 @@
 import static org.hamcrest.CoreMatchers.nullValue;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 /**
@@ -182,6 +187,98 @@ public void testEvents()
         Eventually.assertThat(invoking(listener).getActualTotal(), is(SOME_DATA));
         }
 
+    @Test
+    public void testNoCacheValuesToObservable()
+        {
+        NamedCache<String, Integer>                    testCache = getAndPopulateNamedCache("dist-test");
+        TestCQCListener                                listener  = new ValidateLiteListener(SOME_DATA);
+        ContinuousQueryCache<String, Integer, Integer> theCQC    = setCQC(new ContinuousQueryCache<>(
+                testCache,
+                AlwaysFilter.INSTANCE,
+                /*fCacheValues*/ false,
+                listener,
+                null));
+        assertFalse(theCQC.isCacheValues());
+
+        TestCQCListener listener1  = new TestCQCListener(SOME_DATA);
+        theCQC.addMapListener(listener1, (Filter)null, /*fLite*/ false);
+        assertTrue(theCQC.isCacheValues());
+        testCache.put("moreData", 4);
+        theCQC.release();
+        }
+
+    @Test
+    public void testEventsNoValues()
+        {
+        // put data items into inner cache to generate events
+        NamedCache<String, Integer>                    testCache = getAndPopulateNamedCache("dist-test");
+        TestCQCListener                                listener  = new ValidateLiteListener(SOME_DATA);
+        ContinuousQueryCache<String, Integer, Integer> theCQC    = setCQC(new ContinuousQueryCache<>(
+                testCache,
+                AlwaysFilter.INSTANCE,
+                /*fCacheValues*/ false,
+                listener,
+                null));
+        assertFalse(theCQC.isCacheValues());
+
+
+        // check that the listener received the correct number of events
+        // and the CQC has set its state to STATE_SYNCHRONIZED
+        Eventually.assertThat(invoking(theCQC).getState(), is(ContinuousQueryCache.STATE_SYNCHRONIZED));
+        Eventually.assertThat(invoking(listener).getActualTotal(), is(SOME_DATA));
+        assertFalse(theCQC.isCacheValues());
+
+        // suspend service
+        getFactory().ensureService("CQCTestService").shutdown();
+
+        // verify CQC has received disconnect event before restarting service
+        Eventually.assertThat(invoking(theCQC).getState(), is(ContinuousQueryCache.STATE_DISCONNECTED));
+
+        // reset the listener
+        listener.resetActualTotal();
+
+        // restart the service
+        getFactory().ensureService("CQCTestService").start();
+
+        // ping the CQC for non-existing key to make it realize the cache needs restart
+        theCQC.get("junkKey");
+
+        // check that the listener received the correct number of events after restart
+        Eventually.assertThat(invoking(theCQC).getState(), is(ContinuousQueryCache.STATE_SYNCHRONIZED));
+        Eventually.assertThat(invoking(listener).getActualTotal(), is(SOME_DATA));
+        }
+
+    @Test
+    public void testEventsNoValuesKeyFilter()
+        {
+        NamedCache<String, Integer>                    testCache       = getAndPopulateNamedCache("dist-test");
+        TestCQCListener                                listener        = new ValidateLiteListener(SOME_DATA/2);
+        ContinuousQueryCache<String, Integer, Integer> theCQCFirstHalf = setCQC(new ContinuousQueryCache<>(
+                testCache,
+                new BetweenFilter(new KeyExtractor(), "TestKey00", "TestKey49"),
+                /*fCacheValues*/ false,
+                listener,
+                null));
+        assertFalse(theCQCFirstHalf.isCacheValues());
+
+        TestCQCListener                                listener2        = new ValidateLiteListener(SOME_DATA/2);
+        ContinuousQueryCache<String, Integer, Integer> theCQCSecondHalf = setCQC(new ContinuousQueryCache<>(
+                testCache,
+                new BetweenFilter(new KeyExtractor(), "TestKey50", "TestKey99"),
+                /*fCacheValues*/ false,
+                listener2,
+                null));
+        assertFalse(theCQCSecondHalf.isCacheValues());
+
+        int i = theCQCFirstHalf.get("TestKey09");
+
+        assertTrue(theCQCFirstHalf.size() <= 50);
+        assertTrue(theCQCSecondHalf.size() <= 50);
+
+        Eventually.assertThat(invoking(listener).getActualTotal(), is(SOME_DATA/2));
+        Eventually.assertThat(invoking(listener2).getActualTotal(), is(SOME_DATA/2));
+        }
+
     /**
      * Test the case where an Invoke inserts an entry into the cache
      * to ensure that the event contains the value being inserted.
@@ -736,7 +833,7 @@ protected NamedCache<String, Integer> getAndPopulateNamedCache(String sCacheName
         testCache.clear();
         for (int i = 0; i < SOME_DATA; i++)
             {
-            testCache.put("TestKey" + i, i);
+            testCache.put("TestKey" + String.format("%02d", i), i);
             }
         return testCache;
         }
@@ -961,6 +1058,44 @@ public void writeExternal(PofWriter out)
         private String m_sValue;
         }
 
+    // ----- inner class: ValidateLiteListener -------------------------------
+
+    /**
+     * MapListener that verifies the data received in the event.
+     */
+    @SuppressWarnings("unused")
+    public class ValidateLiteListener extends TestCQCListener
+        {
+        // ----- constructors -----------------------------------------------
+
+        public ValidateLiteListener(int count)
+            {
+            super(count);
+            }
+
+        // ----- MapListener methods ----------------------------------------
+
+        public void entryUpdated(MapEvent evt)
+            {
+            super.entryUpdated(evt);
+            assertNull(evt.getNewValue());
+            assertNull(evt.getOldValue());
+            }
+
+        public void entryInserted(MapEvent evt)
+            {
+            super.entryInserted(evt);
+            assertNull(evt.getNewValue());
+            assertNull(evt.getOldValue());
+            }
+
+        public void entryDeleted(MapEvent evt)
+            {
+            super.entryDeleted(evt);
+            assertNull(evt.getOldValue());
+            }
+        }
+
     /**
      * MapListener that verifies the data received in the event.
      *
diff --git a/prj/test/unit/coherence-tests/src/test/java/com/tangosol/net/cache/ContinuousQueryCacheTest.java b/prj/test/unit/coherence-tests/src/test/java/com/tangosol/net/cache/ContinuousQueryCacheTest.java
@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2000, 2022, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
- * http://oss.oracle.com/licenses/upl.
+ * https://oss.oracle.com/licenses/upl.
  */
 
 package com.tangosol.net.cache;
@@ -12,8 +12,11 @@
 import com.tangosol.net.NamedCache;
 
 import com.oracle.coherence.testing.util.BaseMapTest;
+
+import com.tangosol.util.Extractors;
 import com.tangosol.util.Filter;
 import com.tangosol.util.MapIndex;
+import com.tangosol.util.MapListener;
 import com.tangosol.util.ObservableMap;
 import com.tangosol.util.SimpleMapEntry;
 import com.tangosol.util.ValueExtractor;
@@ -878,6 +881,45 @@ public void testCoh2532()
         BaseMapTest.assertIdenticalMaps(expectedView, cacheCQC);
         }
 
+    /**
+    * Ensure request for no local cache values is ignored when transformer is non-null.
+    */
+    @Test
+    public void testTransformerNoCacheValues()
+        {
+        NamedCache cacheBase = getNewCache("cqc-test");
+        cacheBase.put(1, new Person("111-11-1111", "Homer", "Simpson", 1945, null, new String[0]));
+        cacheBase.put(2, new Person("222-22-2222", "Marge", "Simpson", 1950, null, new String[0]));
+        cacheBase.put(3, new Person("333-33-3333", "Bart", "Simpson", 1985, null, new String[0]));
+        cacheBase.put(4, new Person("444-44-4444", "Lisa", "Simpson", 1987, null, new String[0]));
+
+        ContinuousQueryCache cacheCQC = new ContinuousQueryCache(cacheBase, AlwaysFilter.INSTANCE,
+                                                                 /*fCacheValues*/false, (MapListener)null,
+                                                                 Extractors.extract("firstName"));
+        Assert.assertTrue(cacheCQC.isReadOnly());
+        Assert.assertTrue("ensure non-null transformer results in locally cached values", cacheCQC.isCacheValues());
+
+        Map expectedView = new HashMap(5);
+        expectedView.put(1, "Homer");
+        expectedView.put(2, "Marge");
+        expectedView.put(3, "Bart");
+        expectedView.put(4, "Lisa");
+
+        // ensure transformed values are stored locally despite conflicting request for no local values
+        for (Object oValue : cacheCQC.getInternalCache().values())
+            {
+            assertNotNull(oValue);
+            }
+
+        BaseMapTest.assertIdenticalMaps(expectedView, cacheCQC);
+
+        cacheBase.put(5, new Person("555-55-5555", "Maggie", "Simpson", 2000, null, new String[0]));
+        expectedView.put(5, "Maggie");
+        System.out.println(cacheCQC);
+
+        BaseMapTest.assertIdenticalMaps(expectedView, cacheCQC);
+        }
+
     /**
     * Testable CQC extension that gives access to the index map.
     */
