geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From u..@apache.org
Subject [01/20] incubator-geode git commit: GEODE-1967: Old keys are removed from removedKeyValuesEntries
Date Tue, 11 Oct 2016 03:07:29 GMT
Repository: incubator-geode
Updated Branches:
  refs/heads/feature/GEODE-1801 9b6c10bc2 -> e982284d7


GEODE-1967: Old keys are removed from removedKeyValuesEntries

	* Old keys are removed from removedKeyValuesEntries after the mapping is removed from Compact
map range indexes.
	* New tests were added to handle various scenarios of old keys being destroyed and then inserted
again.


Project: http://git-wip-us.apache.org/repos/asf/incubator-geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-geode/commit/e982284d
Tree: http://git-wip-us.apache.org/repos/asf/incubator-geode/tree/e982284d
Diff: http://git-wip-us.apache.org/repos/asf/incubator-geode/diff/e982284d

Branch: refs/heads/feature/GEODE-1801
Commit: e982284d70e0413653b4fc65dbab64da90997635
Parents: 8f67745
Author: nabarun <nnag@pivotal.io>
Authored: Fri Oct 7 13:57:34 2016 -0700
Committer: Udo Kohlmeyer <ukohlmeyer@pivotal.io>
Committed: Tue Oct 11 14:06:53 2016 +1100

----------------------------------------------------------------------
 .../internal/index/CompactMapRangeIndex.java    |   9 +-
 .../MapRangeIndexMaintenanceJUnitTest.java      | 617 ++++++++++++++++++-
 2 files changed, 622 insertions(+), 4 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/e982284d/geode-core/src/main/java/org/apache/geode/cache/query/internal/index/CompactMapRangeIndex.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/index/CompactMapRangeIndex.java
b/geode-core/src/main/java/org/apache/geode/cache/query/internal/index/CompactMapRangeIndex.java
index 234dfae..61c4e22 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/index/CompactMapRangeIndex.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/index/CompactMapRangeIndex.java
@@ -134,11 +134,14 @@ public class CompactMapRangeIndex extends AbstractMapIndex
       oldKeysAndValuesForEntry = Collections.EMPTY_MAP;
     }
     Set<Entry> removedKeyValueEntries = oldKeysAndValuesForEntry != null ? oldKeysAndValuesForEntry.entrySet()
: Collections.EMPTY_SET;
-     for (Map.Entry<?, ?> keyValue : removedKeyValueEntries) {
+    Iterator<Entry> iterator = removedKeyValueEntries.iterator();
+     while (iterator.hasNext()) {
+       Entry keyValue = iterator.next();
       Object indexKey = keyValue.getKey() == null ? IndexManager.NULL : keyValue.getKey();
        if (!presentKeys.contains(indexKey)) {
-        CompactRangeIndex rg = (CompactRangeIndex) this.mapKeyToValueIndex.get(keyValue.getKey());
-        rg.removeMapping(keyValue.getValue(), entry);
+         CompactRangeIndex rg = (CompactRangeIndex) this.mapKeyToValueIndex.get(keyValue.getKey());
+         rg.removeMapping(keyValue.getValue(), entry);
+         iterator.remove();
       }
     }
   }

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/e982284d/geode-core/src/test/java/org/apache/geode/cache/query/internal/index/MapRangeIndexMaintenanceJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/cache/query/internal/index/MapRangeIndexMaintenanceJUnitTest.java
b/geode-core/src/test/java/org/apache/geode/cache/query/internal/index/MapRangeIndexMaintenanceJUnitTest.java
index b651272..7ed00a4 100644
--- a/geode-core/src/test/java/org/apache/geode/cache/query/internal/index/MapRangeIndexMaintenanceJUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/cache/query/internal/index/MapRangeIndexMaintenanceJUnitTest.java
@@ -82,7 +82,7 @@ public class MapRangeIndexMaintenanceJUnitTest{
     assertEquals(100, region.size());
     qs = CacheUtils.getQueryService();
     
-    keyIndex1 = (IndexProtocol) qs.createIndex(INDEX_NAME, "positions['SUN', 'IBM']", "/portfolio
");
+    keyIndex1 = (IndexProtocol) qs.createIndex(INDEX_NAME, "positions['SUN', 'IBM']", "/portfolio
p");
     
     assertTrue(keyIndex1 instanceof CompactMapRangeIndex);
 
@@ -531,7 +531,622 @@ public class MapRangeIndexMaintenanceJUnitTest{
     assertEquals(1, results.size());
   }
 
+  @Test
+  public void updatingWithSameKeysDifferentValuesAfterRemovingShouldReinsertIndexMappings()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+
+    Portfolio p2 = new Portfolio(1, 1);
+    HashMap map2 = new HashMap();
+    p2.positions = map2;
+    map2.put("GOOG", 1);
+    region.put(1, p2);
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(0, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",3);
+    map3.put("IBM",4);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                              .execute();
+    assertEquals(0, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 3")
+                                .execute();
+    assertEquals(1, results.size());
+
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['GOOG']
= 1")
+                                .execute();
+
+    assertEquals(0, results.size());
+  }
+
+  @Test
+  public void updatingWithSameKeysDifferentValuesAfterRemovingUsingRegionDestroyShouldReinsertIndexMappings()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(1, results.size());
+
+    region.destroy(1);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                              .execute();
+    assertEquals(0, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",3);
+    map3.put("IBM",4);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(0, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 3")
+                                .execute();
+    assertEquals(1, results.size());
+
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['GOOG']
= 1")
+                                .execute();
+
+    assertEquals(0, results.size());
+  }
+
+  @Test
+  public void updatingWithSameKeysDifferentValuesAfterRemovingUsingInplaceModificationShouldReinsertIndexMappings()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+
+
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(1, results.size());
+
+    map1.remove("SUN");
+    map1.remove("IBM");
+    map1.put("GOOG",1);
+
+    region.put(1,p1);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                               .execute();
+    assertEquals(0, results.size());
+
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",3);
+    map3.put("IBM",4);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(0, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 3")
+                                .execute();
+    assertEquals(1, results.size());
+
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['GOOG']
= 1")
+                                .execute();
+
+    assertEquals(0, results.size());
+  }
+
+  @Test
+  public void updatingWithSameKeysSameValuesAfterRemovingShouldReinsertIndexMappings() throws
Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(1, results.size());
+
+    Portfolio p2 = new Portfolio(1, 1);
+    HashMap map2 = new HashMap();
+    p2.positions = map2;
+    map2.put("GOOG", 1);
+    region.put(1, p2);
+
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                              .execute();
+    assertEquals(0, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",1);
+    map3.put("IBM",2);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                              .execute();
+    assertEquals(1, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['IBM']
= 2")
+                                .execute();
+    assertEquals(1, results.size());
+
+  }
+
+  @Test
+  public void updatingWithSameKeysSameValuesAfterRemovingUsingRegionDestroyShouldReinsertIndexMappings()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(1, results.size());
+
+    region.destroy(1);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                              .execute();
+    assertEquals(0, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",1);
+    map3.put("IBM",2);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(1, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['IBM']
= 2")
+                                .execute();
+    assertEquals(1, results.size());
+
+  }
+
+  @Test
+  public void updatingWithSameKeysSameValuesAfterRemovingUsingInPlaceModificationShouldReinsertIndexMappings()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(1, results.size());
+
+    map1.remove("SUN");
+    map1.remove("IBM");
+
+    map1.put("GOOG", 2);
+    region.put(1, p1);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                              .execute();
+    assertEquals(0, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",1);
+    map3.put("IBM",2);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(1, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['IBM']
= 2")
+                                .execute();
+    assertEquals(1, results.size());
+
+  }
+
+
+  @Test
+  public void updatingWithSameKeysSameValuesAfterRemovingShouldReinsertIndexMappingsWithTwoRegionPuts()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+    Portfolio p2 = new Portfolio(1, 1);
+    HashMap map2 = new HashMap();
+    map2.put("SUN", 1);
+    map2.put("IBM", 2);
+    p2.positions = map1;
+    region.put(2, p2);
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(2, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map2.put("GOOG", 1);
+    region.put(1, p3);
+
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(1, results.size());
+
+    Portfolio p4 = new Portfolio(1, 1);
+    HashMap map4 = new HashMap();
+    p4.positions = map4;
+    map4.put("SUN",1);
+    map4.put("IBM",2);
+    region.put(1, p4);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(2, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['IBM']
= 2")
+                                .execute();
+    assertEquals(2, results.size());
+
+  }
+
+  @Test
+  public void updatingWithSameKeysSameValuesAfterRemovingUsingRegionDestroyShouldReinsertIndexMappingsWithTwoRegionPuts()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+    Portfolio p2 = new Portfolio(1, 1);
+    HashMap map2 = new HashMap();
+    map2.put("SUN", 1);
+    map2.put("IBM", 2);
+    p2.positions = map1;
+    region.put(2, p2);
+
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(2, results.size());
+
+    region.destroy(1);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(1, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",1);
+    map3.put("IBM",2);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(2, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['IBM']
= 2")
+                                .execute();
+    assertEquals(2, results.size());
+
+  }
+
+  @Test
+  public void updatingWithSameKeysSameValuesAfterRemovingUsingInPlaceModificationShouldReinsertIndexMappingsWithTwoRegionPuts()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+    Portfolio p2 = new Portfolio(1, 1);
+    HashMap map2 = new HashMap();
+    map2.put("SUN", 1);
+    map2.put("IBM", 2);
+    p2.positions = map1;
+    region.put(2, p2);
+
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(2, results.size());
+
+    map1.remove("SUN");
+    map1.remove("IBM");
+
+    map1.put("GOOG", 2);
+    region.put(1, p1);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(1, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",1);
+    map3.put("IBM",2);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(2, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['IBM']
= 2")
+                                .execute();
+    assertEquals(2, results.size());
+
+  }
+
+  @Test
+  public void updatingWithSameKeysDifferentValuesAfterRemovingShouldReinsertIndexMappingsWithTwoRegionPuts()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",5);
+    map3.put("IBM",6);
+    region.put(2, p3);
+
+
+    Portfolio p2 = new Portfolio(1, 1);
+    HashMap map2 = new HashMap();
+    p2.positions = map2;
+    map2.put("GOOG", 1);
+    region.put(1, p2);
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(0, results.size());
+
+    Portfolio p4 = new Portfolio(1, 1);
+    HashMap map4 = new HashMap();
+    p4.positions = map4;
+    map4.put("SUN",3);
+    map4.put("IBM",4);
+    region.put(1, p4);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(0, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 3")
+                                .execute();
+    assertEquals(1, results.size());
+
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['GOOG']
= 1")
+                                .execute();
+
+    assertEquals(0, results.size());
+  }
+
+  @Test
+  public void updatingWithSameKeysDifferentValuesAfterRemovingUsingRegionDestroyShouldReinsertIndexMappingsWithTwoRegionPuts()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
+
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+    Portfolio p2 = new Portfolio(1, 1);
+    HashMap map2 = new HashMap();
+    map2.put("SUN", 5);
+    map2.put("IBM", 6);
+    p2.positions = map2;
+    region.put(2, p2);
+
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(1, results.size());
+
+    region.destroy(1);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(0, results.size());
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",3);
+    map3.put("IBM",4);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(0, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 3")
+                                .execute();
+    assertEquals(1, results.size());
+
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['GOOG']
= 1")
+                                .execute();
+
+    assertEquals(0, results.size());
+  }
+
+  @Test
+  public void updatingWithSameKeysDifferentValuesAfterRemovingUsingInplaceModificationShouldReinsertIndexMappingsWithTwoRegionPuts()
throws Exception {
+    AttributesFactory af = new AttributesFactory();
+    af.setScope(Scope.LOCAL);
+    region = CacheUtils.createRegion("portfolio", af.create(), false);
+    qs = CacheUtils.getQueryService();
+    Index keyIndex1 = qs.createIndex(INDEX_NAME, "positions[*]", "/portfolio");
 
+    Portfolio p1 = new Portfolio(1, 1);
+    HashMap map1 = new HashMap();
+    map1.put("SUN", 1);
+    map1.put("IBM", 2);
+    p1.positions = map1;
+    region.put(1, p1);
+
+
+    Portfolio p2 = new Portfolio(1, 1);
+    HashMap map2 = new HashMap();
+    map2.put("SUN", 5);
+    map2.put("IBM", 6);
+    p2.positions = map2;
+    region.put(2, p2);
+
+    SelectResults results = (SelectResults) qs.newQuery("select * from /portfolio p where
p.positions['SUN'] = 1")
+                                              .execute();
+    assertEquals(1, results.size());
+
+    map1.remove("SUN");
+    map1.remove("IBM");
+    map1.put("GOOG",1);
+
+    region.put(1,p1);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(0, results.size());
+
+
+    Portfolio p3 = new Portfolio(1, 1);
+    HashMap map3 = new HashMap();
+    p3.positions = map3;
+    map3.put("SUN",3);
+    map3.put("IBM",4);
+    region.put(1, p3);
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 1")
+                                .execute();
+    assertEquals(0, results.size());
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['SUN']
= 3")
+                                .execute();
+    assertEquals(1, results.size());
+
+
+    results = (SelectResults) qs.newQuery("select * from /portfolio p where p.positions['GOOG']
= 1")
+                                .execute();
+
+    assertEquals(0, results.size());
+  }
 
 
   /**


Mime
View raw message