geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kl...@apache.org
Subject [11/94] [abbrv] [partial] incubator-geode git commit: Merge remote-tracking branch 'origin/develop' into feature/GEODE-917
Date Tue, 23 Feb 2016 20:23:07 GMT
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/5beaaedc/geode-core/src/test/java/com/gemstone/gemfire/cache/query/internal/index/IndexUseJUnitTest.java
----------------------------------------------------------------------
diff --cc geode-core/src/test/java/com/gemstone/gemfire/cache/query/internal/index/IndexUseJUnitTest.java
index c3223d8,0000000..b171ac1
mode 100644,000000..100644
--- a/geode-core/src/test/java/com/gemstone/gemfire/cache/query/internal/index/IndexUseJUnitTest.java
+++ b/geode-core/src/test/java/com/gemstone/gemfire/cache/query/internal/index/IndexUseJUnitTest.java
@@@ -1,1890 -1,0 +1,1654 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to You under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + *      http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
- /*
-  * IndexTest.java
-  *
-  * Created on February 23, 2005, 3:17 PM
-  */
 +package com.gemstone.gemfire.cache.query.internal.index;
 +
 +import static org.junit.Assert.assertEquals;
 +import static org.junit.Assert.assertFalse;
 +import static org.junit.Assert.assertTrue;
 +import static org.junit.Assert.fail;
 +
 +import java.util.ArrayList;
 +import java.util.Collection;
 +import java.util.HashMap;
 +import java.util.Iterator;
 +import java.util.List;
 +import java.util.Map;
 +
 +import org.junit.After;
 +import org.junit.Before;
 +import org.junit.Test;
 +import org.junit.experimental.categories.Category;
 +
 +import com.gemstone.gemfire.cache.AttributesFactory;
++import com.gemstone.gemfire.cache.Cache;
 +import com.gemstone.gemfire.cache.PartitionAttributesFactory;
 +import com.gemstone.gemfire.cache.Region;
++import com.gemstone.gemfire.cache.RegionShortcut;
 +import com.gemstone.gemfire.cache.query.CacheUtils;
 +import com.gemstone.gemfire.cache.query.Index;
 +import com.gemstone.gemfire.cache.query.IndexType;
 +import com.gemstone.gemfire.cache.query.Query;
 +import com.gemstone.gemfire.cache.query.QueryInvalidException;
 +import com.gemstone.gemfire.cache.query.QueryService;
 +import com.gemstone.gemfire.cache.query.SelectResults;
 +import com.gemstone.gemfire.cache.query.Struct;
 +import com.gemstone.gemfire.cache.query.data.Portfolio;
 +import com.gemstone.gemfire.cache.query.functional.StructSetOrResultsSet;
 +import com.gemstone.gemfire.cache.query.internal.QueryObserverAdapter;
 +import com.gemstone.gemfire.cache.query.internal.QueryObserverHolder;
 +import com.gemstone.gemfire.cache.query.internal.index.IndexManager.TestHook;
 +import com.gemstone.gemfire.internal.cache.LocalRegion;
 +import com.gemstone.gemfire.test.junit.categories.IntegrationTest;
 +
 +/**
 + * 
 + * @author vaibhav
 + */
 +@Category(IntegrationTest.class)
 +public class IndexUseJUnitTest
 +{
 +
 +  Region region;
 +
 +  QueryService qs;
 +
 +  @Before
 +  public void setUp() throws Exception {
 +    CacheUtils.startCache();
 +    region = CacheUtils.createRegion("pos", Portfolio.class);
 +    region.put("0", new Portfolio(0));
 +    region.put("1", new Portfolio(1));
 +    region.put("2", new Portfolio(2));
 +    region.put("3", new Portfolio(3));
 +
 +    qs = CacheUtils.getQueryService();
 +    qs.createIndex("statusIndex", IndexType.FUNCTIONAL, "status", "/pos");
 +    qs.createIndex("idIndex", IndexType.FUNCTIONAL, "ID", "/pos");
 +    qs.createIndex("secIdIndex", IndexType.FUNCTIONAL, "P1.secId", "/pos");
 +    qs.createIndex("secIdIndex2", IndexType.FUNCTIONAL, "P2.secId", "/pos");
 +    qs.createIndex("p1secindex", "p.position1.secId", " /pos p ");
 +  }
 +
 +  @After
 +  public void tearDown() throws Exception {
 +    CacheUtils.closeCache();
 +    IndexManager indexManager = ((LocalRegion)region).getIndexManager();
 +    if (indexManager != null)
 +      indexManager.destroy();
 +    IndexManager.TEST_RANGEINDEX_ONLY = false;
 +    
 +  }
 +
 +  @Test
 +  public void testIndexUseSingleCondition() throws Exception {
 +    String testData[][] = { { "status", "'active'" }, { "ID", "2" },
 +        { "P1.secId", "'IBM'" }, };
 +    String operators[] = { "=", "<>", "!=", "<", "<=", ">", ">=" };
 +    for (int i = 0; i < operators.length; i++) {
 +      String operator = operators[i];
 +      for (int j = 0; j < testData.length; j++) {
 +        Query q = qs.newQuery("SELECT DISTINCT * FROM /pos where "
 +            + testData[j][0] + " " + operator + " " + testData[j][1]);
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        q.execute();
 +        if (!observer.isIndexesUsed) {
-           fail("Index not uesd for operator '" + operator + "'");
++          fail("Index not used for operator '" + operator + "'");
 +        }
 +      }
 +    }
 +  }
 +
 +  @Test
 +  public void testIndexUseMultipleConditions() throws Exception {
 +    String testData[][] = { { "P1.secType = 'a'", "0" },
 +        { "status = 'active' AND ID = 2", "1" },
 +        { "status = 'active' AND ID = 2 AND P1.secId  = 'IBM'", "1" },
 +        { "status = 'active' OR ID = 2", "2" },
 +        { "status = 'active' OR ID = 2 OR P1.secId  = 'IBM'", "3" },
 +        { "status = 'active' AND ID = 2 OR P1.secId  = 'IBM'", "2" },
 +        { "status = 'active' AND ( ID = 2 OR P1.secId  = 'IBM')", "1" },
 +        { "status = 'active' OR ID = 2 AND P1.secId  = 'IBM'", "2" },
 +        { "(status = 'active' OR ID = 2) AND P1.secId  = 'IBM'", "1" },
 +        { "NOT (status = 'active') AND ID = 2", "1" },
 +        { "status = 'active' AND NOT( ID = 2 )", "1" },
 +        { "NOT (status = 'active') OR ID = 2", "2" },
 +        { "status = 'active' OR NOT( ID = 2 )", "2" },
 +        { "status = 'active' AND P1.secType = 'a'", "1" },
 +        { "status = 'active' OR P1.secType = 'a'", "0" },
 +        { "status = 'active' AND ID =1 AND P1.secType = 'a'", "1" },
 +        { "status = 'active' AND ID = 1 OR P1.secType = 'a'", "0" },
 +        { "status = 'active' OR ID = 1 AND P1.secType = 'a'", "2" },
 +        { "P2.secId = null", "1" }, { "IS_UNDEFINED(P2.secId)", "1" },
 +        { "IS_DEFINED(P2.secId)", "1" }, { "P2.secId = UNDEFINED", "0" }, };
 +    for (int j = 0; j < testData.length; j++) {
 +      Query q = qs.newQuery("SELECT DISTINCT * FROM /pos where "
 +          + testData[j][0]);
 +      QueryObserverImpl observer = new QueryObserverImpl();
 +      QueryObserverHolder.setInstance(observer);
 +      q.execute();
 +      if (observer.indexesUsed.size() != Integer.parseInt(testData[j][1])) {
 +        fail("Wrong Index use for " + testData[j][0] + "\n Indexes used "
 +            + observer.indexesUsed);
 +      }
 +    }
 +  }
 +
 +  /**
 +   * Test to check if Region object is passed as bind argument, the index
 +   * utilization occurs or not
 +   * @author ashahid
 +   */
 +  @Test
 +  public void testBug36421_part1() {
 +    try {
 +      String testData[][] = { { "status", "'active'" }, };
 +      String operators[] = { "=" };
 +      for (int i = 0; i < operators.length; i++) {
 +        String operator = operators[i];
 +        for (int j = 0; j < testData.length; j++) {
 +          Query q = qs.newQuery("SELECT DISTINCT * FROM $1 where "
 +              + testData[j][0] + " " + operator + " " + testData[j][1]);
 +          QueryObserverImpl observer = new QueryObserverImpl();
 +          QueryObserverHolder.setInstance(observer);
 +          q.execute(new Object[] { CacheUtils.getRegion("/pos") });
 +          if (!observer.isIndexesUsed) {
-             fail("Index not uesd for operator '" + operator + "'");
++            fail("Index not used for operator '" + operator + "'");
 +          }
 +        }
 +      }
 +    }
 +    catch (Exception e) {
 +      CacheUtils.getLogger().error(e);
-       fail("Test faield due to exception =" + e);
++      fail("Test failed due to exception =" + e);
 +    }
 +  }
 +
 +  /**
 +   * Test to check if Region short cut method is used for querying, the index
 +   * utilization occurs or not
 +   * @author ashahid
 +   */
 +  @Test
 +  public void testBug36421_part2() {
 +    try {
 +      String testData[][] = { { "status", "'active'" }, };
 +      String operators[] = { "=" };
 +      for (int i = 0; i < operators.length; i++) {
 +        String operator = operators[i];
 +        for (int j = 0; j < testData.length; j++) {
 +
 +          QueryObserverImpl observer = new QueryObserverImpl();
 +          QueryObserverHolder.setInstance(observer);
 +          CacheUtils.getRegion("/pos").query(
 +              testData[j][0] + " " + operator + " " + testData[j][1]);
 +          if (!observer.isIndexesUsed) {
-             fail("Index not uesd for operator '" + operator + "'");
++            fail("Index not used for operator '" + operator + "'");
 +          }
 +        }
 +      }
 +    }
 +    catch (Exception e) {
 +      CacheUtils.getLogger().error(e);
 +      fail("Test failed due to exception =" + e);
 +    }
 +  }
 +
 +  /**
 +   * Test to check if a parametrized query when using different bind arguments
 +   * of Region uses the index correctly
 +   * @author ashahid
 +   */
 +  @Test
 +  public void testBug36421_part3() {
 +
 +    Query q = null;
 +    try {
 +      q = qs.newQuery("SELECT DISTINCT * FROM $1 z where z.status = 'active'");
 +      QueryObserverImpl observer = new QueryObserverImpl();
 +      QueryObserverHolder.setInstance(observer);
 +      q.execute(new Object[] { CacheUtils.getRegion("/pos") });
 +      if (!observer.isIndexesUsed) {
 +        fail("Index not uesd for operator '='");
 +      }
 +      assertTrue(observer.indexesUsed.get(0).equals("statusIndex"));
 +      region = CacheUtils.createRegion("pos1", Portfolio.class);
 +      region.put("0", new Portfolio(0));
 +      region.put("1", new Portfolio(1));
 +      region.put("2", new Portfolio(2));
 +      region.put("3", new Portfolio(3));
 +      qs.createIndex("statusIndex1", IndexType.FUNCTIONAL, "pf1.status",
 +          "/pos1 pf1");
 +      region.put("4", new Portfolio(4));
 +      observer = new QueryObserverImpl();
 +      QueryObserverHolder.setInstance(observer);
 +      q.execute(new Object[] { CacheUtils.getRegion("/pos1") });
 +      if (!observer.isIndexesUsed) {
-         fail("Index not uesd for operator'='");
++        fail("Index not used for operator'='");
 +      }
 +      assertTrue(observer.indexesUsed.get(0).equals("statusIndex1"));
 +
 +    }
 +    catch (Exception e) {
 +      CacheUtils.getLogger().error(e);
 +      fail("Test failed due to exception =" + e);
 +    }
 +  }
 +
 +  /**
 +   * Test to check if Region short cut method is used for querying, the Primary
 +   * key index utilization occurs or not 
 +   * @author ashahid
 +   */
 +  @Test
 +  public void testBug36421_part4() {
 +//    Query q = null;
 +    try {
 +      qs.createIndex("pkIndex", IndexType.PRIMARY_KEY, "pk", "/pos");
 +      QueryObserverImpl observer = new QueryObserverImpl();
 +      QueryObserverHolder.setInstance(observer);
 +      SelectResults rs = CacheUtils.getRegion("/pos").query("pk = '2'");
 +      if (!observer.isIndexesUsed) {
 +        fail("Index not uesd for operator '='");
 +      }
 +      assertTrue(rs.size() == 1);
 +      assertTrue(((Portfolio)rs.iterator().next()).pkid.equals("2"));
 +      assertTrue(observer.indexesUsed.get(0).equals("pkIndex"));
 +      CacheUtils.getRegion("/pos").put("7", new Portfolio(7));
 +      observer = new QueryObserverImpl();
 +      QueryObserverHolder.setInstance(observer);
 +      rs = CacheUtils.getRegion("/pos").query("pk = '7'");
 +      if (!observer.isIndexesUsed) {
-         fail("Index not uesd for operator '='");
++        fail("Index not used for operator '='");
 +      }
 +      assertTrue(rs.size() == 1);
 +      assertTrue(((Portfolio)rs.iterator().next()).pkid.equals("7"));
 +      assertTrue(observer.indexesUsed.get(0).equals("pkIndex"));
 +    }
 +    catch (Exception e) {
 +      CacheUtils.getLogger().error(e);
 +      fail("Test failed due to exception =" + e);
 +    }
 +  }
 +  
 +  @Test
 +  public void testMapIndexUsageAllKeys() throws Exception {
++    try {
++      IndexManager.TEST_RANGEINDEX_ONLY = true;
++      evaluateMapTypeIndexUsageAllKeys();
++    }
++    finally {
++      IndexManager.TEST_RANGEINDEX_ONLY = false;
++    }
++  }
++  
++  private void evaluateMapTypeIndexUsageAllKeys() throws Exception {
 +    QueryService qs;
 +    qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    int ID =1;
 +    //Add some test data now
 +    //Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for(; ID <=30; ++ID) {
 +      MapKeyIndexData mkid = new MapKeyIndexData(ID);
 +      for(int j =1; j<= ID;++j) {
 +        mkid.maap.put("key1", j*1);
 +        mkid.maap.put("key2", j*2);
 +        mkid.maap.put("key3", j*3);
 +      }
 +      testRgn.put(ID, mkid);
 +    }
 +    String queries[] = {
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 16"
 +       /* "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap.get('key2') >= 16" ,*/        
 +    };
 +    String queriesIndexNotUsed[] = {        
 +         "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap.get('key2') >= 16"         
 +     };
 +    Object r[][]= new Object[queries.length][2];
 +    
 +    qs = CacheUtils.getQueryService();
 +    
 +  //Execute Queries without Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +        Query q = null;
 +        try {
 +            q = CacheUtils.getQueryService().newQuery(queries[i]);
 +            CacheUtils.getLogger().info("Executing query: " + queries[i]);              
 +            r[i][0] = q.execute();         
 +          CacheUtils.log("Executed query: " + queries[i] );
 +        } catch (Exception e) {
 +            e.printStackTrace();
 +            fail(q.getQueryString());
 +        }
 +    }  
 +    
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL, "objs.maap[*]",
 +        "/testRgn objs");
 +    
 +          //Execute Queries with Indexes
 +      for (int i = 0; i < queries.length; i++) {
 +          Query q = null;
 +          try {
 +              q = CacheUtils.getQueryService().newQuery(queries[i]);
 +              CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +              QueryObserverImpl observer = new QueryObserverImpl();
 +              QueryObserverHolder.setInstance(observer);
 +              r[i][1] = q.execute();
 +              CacheUtils.log("Executing query: " + queries[i] + " with index created");
 +              if(!observer.isIndexesUsed){
-                   fail("Index is NOT uesd");
++                  fail("Index is NOT used");
 +              }              
 +              Iterator itr = observer.indexesUsed.iterator();
 +              assertTrue(itr.hasNext());
 +              String temp = itr.next().toString();
 +              assertEquals(temp,"Index1");       
 +              
 +          } catch (Exception e) {
 +              e.printStackTrace();
 +              fail(q.getQueryString());
 +          }
 +      }
 +      StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +      ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r,queries.length,queries);
 +      
 +      //Test queries index not used
 +      for (int i = 0; i < queriesIndexNotUsed.length; i++) {
 +        Query q = null;
 +        try {
 +            q = CacheUtils.getQueryService().newQuery(queriesIndexNotUsed[i]);
 +            CacheUtils.getLogger().info("Executing query: " + queriesIndexNotUsed[i]);
 +            QueryObserverImpl observer = new QueryObserverImpl();
 +            QueryObserverHolder.setInstance(observer);            
 +            CacheUtils.log("Executing query: " + queriesIndexNotUsed[i] + " with index created");
 +            q.execute();
 +            assertFalse(observer.isIndexesUsed);                          
 +            Iterator itr = observer.indexesUsed.iterator();
 +            assertFalse(itr.hasNext());                   
 +            
 +        } catch (Exception e) {
 +            e.printStackTrace();
 +            fail(q.getQueryString());
 +        }
 +    }
 +      
 +  }
 +  
 +  @Test
 +  public void testCompactMapIndexUsageWithIndexOnSingleKey() throws Exception
 +  {
-     QueryService qs;
-     qs = CacheUtils.getQueryService();
++    String queries[] = {
++        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3"};
++    String queriesIndexNotUsed[] = {
++        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap.get('key2') >= 3"};
++
++    
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    int ID = 1;
 +    // Add some test data now
 +    // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for (; ID <= 30; ++ID) {
 +      MapKeyIndexData mkid = new MapKeyIndexData(ID);
 +      for (int j = 1; j <= ID; ++j) {
 +        mkid.addKeyValue("key1", j * 1);
 +        mkid.addKeyValue("key2", j * 2);
 +        mkid.addKeyValue("key3", j * 3);
 +      }
 +      testRgn.put(ID, mkid);
 +    }
- 
-     qs = CacheUtils.getQueryService();
-     String queries[] = { "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3" };
- 
-     String queriesIndexNotUsed[] = {
-         "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap.get('key2') >= 3",
-         "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key3'] >= 3", };
- 
-     Object r[][] = new Object[queries.length][2];
- 
-     // Execute Queries without Indexes
-     for (int i = 0; i < queries.length; i++) {
-       Query q = null;
-       try {
-         q = CacheUtils.getQueryService().newQuery(queries[i]);
-         CacheUtils.getLogger().info("Executing query: " + queries[i]);
-         r[i][0] = q.execute();
-         CacheUtils.log("Executed query: " + queries[i]);
-       }
-       catch (Exception e) {
-         e.printStackTrace();
-         fail(q.getQueryString());
-       }
-     }
- 
-     Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
-         "objs.maap['key2']", "/testRgn objs");
-     assertTrue(i1 instanceof CompactRangeIndex);
-     // Execute Queries with Indexes
-     for (int i = 0; i < queries.length; i++) {
-       Query q = null;
-       try {
-         q = CacheUtils.getQueryService().newQuery(queries[i]);
-         CacheUtils.getLogger().info("Executing query: " + queries[i]);
-         QueryObserverImpl observer = new QueryObserverImpl();
-         QueryObserverHolder.setInstance(observer);
-         r[i][1] = q.execute();
-         CacheUtils.log("Executing query: " + queries[i]
-             + " with index created");
-         if (!observer.isIndexesUsed) {
-           fail("Index is NOT uesd");
-         }
-         Iterator itr = observer.indexesUsed.iterator();
-         assertTrue(itr.hasNext());
-         String temp = itr.next().toString();
-         assertEquals(temp, "Index1");
- 
-       }
-       catch (Exception e) {
-         e.printStackTrace();
-         fail(q.getQueryString());
-       }
-     }
-     StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
-     ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r, queries.length,queries);
- 
-     // Test queries index not used
-     for (int i = 0; i < queriesIndexNotUsed.length; i++) {
-       Query q = null;
-       try {
-         q = CacheUtils.getQueryService().newQuery(queriesIndexNotUsed[i]);
-         CacheUtils.getLogger().info(
-             "Executing query: " + queriesIndexNotUsed[i]);
-         QueryObserverImpl observer = new QueryObserverImpl();
-         QueryObserverHolder.setInstance(observer);
-         CacheUtils.log("Executing query: " + queriesIndexNotUsed[i]
-             + " with index created");
-         q.execute();
-         assertFalse(observer.isIndexesUsed);
-         Iterator itr = observer.indexesUsed.iterator();
-         assertFalse(itr.hasNext());
- 
-       }
-       catch (Exception e) {
-         e.printStackTrace();
-         fail(q.getQueryString());
-       }
-     }
++    
++    evaluateMapTypeIndexUsage("objs.maap['key2']", "/testRgn objs", queries, queriesIndexNotUsed, CompactRangeIndex.class);
 +
 +    String query = "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.liist[0] >= 2";
 +    SelectResults withoutIndex, withIndex;
 +    Query q = CacheUtils.getQueryService().newQuery(query);
 +    CacheUtils.getLogger().info("Executing query: " + query);
 +    withoutIndex = (SelectResults)q.execute();
 +    CacheUtils.log("Executed query: " + query);
 +
 +    Index i2 = qs.createIndex("Index2", IndexType.FUNCTIONAL, "objs.liist[0]",
 +        "/testRgn objs");
 +    assertTrue(i2 instanceof CompactRangeIndex);
 +    CacheUtils.getLogger().info("Executing query: " + query);
 +    QueryObserverImpl observer = new QueryObserverImpl();
 +    QueryObserverHolder.setInstance(observer);
 +    withIndex = (SelectResults)q.execute();
 +    CacheUtils.log("Executing query: " + query + " with index created");
 +    if (!observer.isIndexesUsed) {
 +      fail("Index is NOT uesd");
 +    }
 +    Iterator itr = observer.indexesUsed.iterator();
 +    assertTrue(itr.hasNext());
 +    String temp = itr.next().toString();
 +    assertEquals(temp, "Index2");
 +
-     ssOrrs = new StructSetOrResultsSet();
++    StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +    ssOrrs.CompareQueryResultsWithoutAndWithIndexes(new Object[][] { {
 +        withoutIndex, withIndex } }, 1,queries);
 +
 +  }
 +  @Test
 +  public void testCompactMapIndexUsageWithIndexOnMultipleKeys() throws Exception
 +  {
-     QueryService qs;
-     qs = CacheUtils.getQueryService();
-     LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
-     int ID = 1;
-     // Add some test data now
-     // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
-     // and so on
-     for (; ID <= 30; ++ID) {
-       MapKeyIndexData mkid = new MapKeyIndexData(ID);
-       for (int j = 1; j <= ID; ++j) {
-         mkid.addKeyValue("key1", j * 1);
-         mkid.addKeyValue("key2", j * 2);
-         mkid.addKeyValue("key3", j * 3);
-       }
-       testRgn.put(ID, mkid);
-     }
- 
-     qs = CacheUtils.getQueryService();
 +    String queries[] = {
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3",
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key3'] >= 3" };
- 
 +    String queriesIndexNotUsed[] = {
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap.get('key2') >= 16",
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key4'] >= 16", };
 +
-     Object r[][] = new Object[queries.length][2];
- 
-     // Execute Queries without Indexes
-     for (int i = 0; i < queries.length; i++) {
-       Query q = null;
-       try {
-         q = CacheUtils.getQueryService().newQuery(queries[i]);
-         CacheUtils.getLogger().info("Executing query: " + queries[i]);
-         r[i][0] = q.execute();
-         CacheUtils.log("Executed query: " + queries[i]);
-       }
-       catch (Exception e) {
-         e.printStackTrace();
-         fail(q.getQueryString());
-       }
-     }
- 
-     Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
-         "objs.maap['key2','key3']", "/testRgn objs");
-     assertTrue(i1 instanceof CompactMapRangeIndex);
-     // Execute Queries with Indexes
-     for (int i = 0; i < queries.length; i++) {
-       Query q = null;
-       try {
-         q = CacheUtils.getQueryService().newQuery(queries[i]);
-         CacheUtils.getLogger().info("Executing query: " + queries[i]);
-         QueryObserverImpl observer = new QueryObserverImpl();
-         QueryObserverHolder.setInstance(observer);
-         r[i][1] = q.execute();
-         CacheUtils.log("Executing query: " + queries[i]
-             + " with index created");
-         if (!observer.isIndexesUsed) {
-           fail("Index is NOT uesd");
-         }
-         Iterator itr = observer.indexesUsed.iterator();
-         assertTrue(itr.hasNext());
-         String temp = itr.next().toString();
-         assertEquals(temp, "Index1");
- 
-       }
-       catch (Exception e) {
-         e.printStackTrace();
-         fail(q.getQueryString());
-       }
-     }
-     StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
-     ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r, queries.length,queries);
- 
-     // Test queries index not used
-     for (int i = 0; i < queriesIndexNotUsed.length; i++) {
-       Query q = null;
-       try {
-         q = CacheUtils.getQueryService().newQuery(queriesIndexNotUsed[i]);
-         CacheUtils.getLogger().info(
-             "Executing query: " + queriesIndexNotUsed[i]);
-         QueryObserverImpl observer = new QueryObserverImpl();
-         QueryObserverHolder.setInstance(observer);
-         CacheUtils.log("Executing query: " + queriesIndexNotUsed[i]
-             + " with index created");
-         q.execute();
-         assertFalse(observer.isIndexesUsed);
-         Iterator itr = observer.indexesUsed.iterator();
-         assertFalse(itr.hasNext());
- 
-       }
-       catch (Exception e) {
-         e.printStackTrace();
-         fail(q.getQueryString());
-       }
-     }
- 
-   }
-       
-   @Test
-   public void testMapIndexUsageWithIndexOnMultipleKeys() throws Exception
-   {
-     IndexManager.TEST_RANGEINDEX_ONLY = true;
-     QueryService qs;
-     qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    int ID = 1;
 +    // Add some test data now
 +    // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for (; ID <= 30; ++ID) {
 +      MapKeyIndexData mkid = new MapKeyIndexData(ID);
 +      for (int j = 1; j <= ID; ++j) {
 +        mkid.addKeyValue("key1", j * 1);
 +        mkid.addKeyValue("key2", j * 2);
 +        mkid.addKeyValue("key3", j * 3);
 +      }
 +      testRgn.put(ID, mkid);
 +    }
++    evaluateMapTypeIndexUsage("objs.maap['key2','key3']", "/testRgn objs", queries, queriesIndexNotUsed, CompactMapRangeIndex.class);
++  }
++      
++  @Test
++  public void testMapIndexUsageWithIndexOnMultipleKeys() throws Exception
++  {
++    try {
++      IndexManager.TEST_RANGEINDEX_ONLY = true;
++      String queries[] = {
++          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3",
++          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key3'] >= 3" };
++      String queriesIndexNotUsed[] = {
++          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap.get('key2') >= 16",
++          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key4'] >= 16", };
 +
-     qs = CacheUtils.getQueryService();
-     String queries[] = {
-         "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3",
-         "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key3'] >= 3" };
- 
-     String queriesIndexNotUsed[] = {
-         "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap.get('key2') >= 16",
-         "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key4'] >= 16", };
- 
++      
++      LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
++      int ID = 1;
++      // Add some test data now
++      // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
++      // and so on
++      for (; ID <= 30; ++ID) {
++        MapKeyIndexData mkid = new MapKeyIndexData(ID);
++        for (int j = 1; j <= ID; ++j) {
++          mkid.addKeyValue("key1", j * 1);
++          mkid.addKeyValue("key2", j * 2);
++          mkid.addKeyValue("key3", j * 3);
++        }
++        testRgn.put(ID, mkid);
++      }
++      
++      evaluateMapTypeIndexUsage("objs.maap['key2','key3']", "/testRgn objs", queries, queriesIndexNotUsed, MapRangeIndex.class);
++    }
++    finally {
++      IndexManager.TEST_RANGEINDEX_ONLY = false;
++    }
++  }
++  
++  private void evaluateMapTypeIndexUsage(String indexExpression, String fromClause, String[] queries, String[] queriesIndexNotUsed, Class expectedIndexClass) throws Exception {
++    QueryService qs = CacheUtils.getQueryService();
++   
 +    Object r[][] = new Object[queries.length][2];
 +
 +    // Execute Queries without Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        r[i][0] = q.execute();
 +        CacheUtils.log("Executed query: " + queries[i]);
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
-         "objs.maap['key2','key3']", "/testRgn objs");
-     assertTrue(i1 instanceof MapRangeIndex);
++        indexExpression, fromClause);
++    assertTrue(i1.getClass().equals(expectedIndexClass));
++    
 +    // Execute Queries with Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        r[i][1] = q.execute();
 +        CacheUtils.log("Executing query: " + queries[i]
 +            + " with index created");
 +        if (!observer.isIndexesUsed) {
-           fail("Index is NOT uesd");
++          fail("Index is NOT used");
 +        }
 +        Iterator itr = observer.indexesUsed.iterator();
 +        assertTrue(itr.hasNext());
 +        String temp = itr.next().toString();
 +        assertEquals(temp, "Index1");
 +
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +    StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +    ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r, queries.length,queries);
 +
 +    // Test queries index not used
 +    for (int i = 0; i < queriesIndexNotUsed.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queriesIndexNotUsed[i]);
 +        CacheUtils.getLogger().info(
 +            "Executing query: " + queriesIndexNotUsed[i]);
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        CacheUtils.log("Executing query: " + queriesIndexNotUsed[i]
 +            + " with index created");
 +        q.execute();
 +        assertFalse(observer.isIndexesUsed);
 +        Iterator itr = observer.indexesUsed.iterator();
 +        assertFalse(itr.hasNext());
 +
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
- 
 +  }
 +
 +  @Test
 +  public void testIndexUsageWithOrderBy() throws Exception
 +  {
 +    QueryService qs;
 +    qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    
 +    int numObjects = 30;
 +    // Add some test data now
 +    // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for (int i=0; i < numObjects; i++) {
 +      Portfolio p = new Portfolio(i);
 +      p.pkid = ("" +(numObjects - i));
 +      testRgn.put("" + i, p);
 +    }
 +
 +    qs = CacheUtils.getQueryService();
 +    String queries[] = {
 +        "SELECT DISTINCT * FROM /testRgn p  WHERE p.ID <= 10 order by p.pkid asc limit 1",
 +        "SELECT DISTINCT * FROM /testRgn p  WHERE p.ID <= 10 order by p.pkid desc limit 1",
 +    };
 +
 +    Object r[][] = new Object[queries.length][2];
 +
 +    // Execute Queries without Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        // verify individual result
 +        SelectResults sr = (SelectResults)q.execute();
 +        List results = sr.asList();
 +        for (int rows=0; rows < results.size(); rows++) {
 +          Portfolio p = (Portfolio)results.get(0);
 +          CacheUtils.getLogger().info("p: " + p);
 +          if (i == 0) {
 +            assertEquals(p.getID(), 10);
 +            assertEquals(p.pkid, "" + (numObjects - 10));
 +          } else if (i == 1) {
 +            assertEquals(p.getID(), 0);
 +            assertEquals(p.pkid, "" + numObjects);
 +          }
 +        }
 +        r[i][0] = sr;
 +        CacheUtils.log("Executed query: " + queries[i]);
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL, "p.ID", "/testRgn p");
 + 
 +    // Execute Queries with Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        SelectResults sr = (SelectResults)q.execute();
 +        List results = sr.asList();
 +        for (int rows=0; rows < results.size(); rows++) {
 +          Portfolio p = (Portfolio)results.get(0);
 +          CacheUtils.getLogger().info("index p: " + p);
 +          if (i == 0) {
 +            assertEquals(p.getID(), 10);
 +            assertEquals(p.pkid, "" + (numObjects - 10));
 +          } else if (i == 1) {
 +            assertEquals(p.getID(), 0);
 +            assertEquals(p.pkid, "" + numObjects);
 +          }
 +        }
 +        r[i][1] = sr;
 +        //r[i][1] = q.execute();
 +        CacheUtils.log("Executing query: " + queries[i]
 +            + " with index created");
 +        if (!observer.isIndexesUsed) {
 +          fail("Index is NOT uesd");
 +        }
 +        Iterator itr = observer.indexesUsed.iterator();
 +        assertTrue(itr.hasNext());
 +        String temp = itr.next().toString();
 +        assertEquals(temp, "Index1");
 +      }
 +      
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +    StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +    ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r, queries.length,queries);
 +  }
 +  
 +  @Test
 +  public void testIndexUsageWithOrderBy3() throws Exception
 +  {
 +    QueryService qs;
 +    qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    
 +    int numObjects = 30;
 +    // Add some test data now
 +    // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for (int i=0; i < numObjects; i++) {
 +      Portfolio p = new Portfolio(i);
 +      p.pkid = ("" +(numObjects - i));
 +      testRgn.put("" + i, p);
 +    }
 +
 +    qs = CacheUtils.getQueryService();
 +    String queries[] = {
 +        "SELECT DISTINCT * FROM /testRgn p  WHERE p.ID <= 10 order by ID asc limit 1",
 +        "SELECT DISTINCT * FROM /testRgn p  WHERE p.ID <= 10 order by p.ID desc limit 1",
 +    };
 +
 +    Object r[][] = new Object[queries.length][2];
 +
 +    
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL, "p.ID", "/testRgn p");
 + 
 +    // Execute Queries with Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        SelectResults sr = (SelectResults)q.execute();
 +        List results = sr.asList();
 +        for (int rows=0; rows < results.size(); rows++) {
 +          Portfolio p = (Portfolio)results.get(0);
 +          CacheUtils.getLogger().info("index p: " + p);
 +          if (i == 0) {
 +            assertEquals(p.getID(), 0);
 +            
 +          } else if (i == 1) {
 +            assertEquals(p.getID(), 10);
 +            
 +          }
 +        }
 +        r[i][1] = sr;
 +        //r[i][1] = q.execute();
 +        CacheUtils.log("Executing query: " + queries[i]
 +            + " with index created");
 +        if (!observer.isIndexesUsed) {
 +          fail("Index is NOT uesd");
 +        }
 +        Iterator itr = observer.indexesUsed.iterator();
 +        assertTrue(itr.hasNext());
 +        String temp = itr.next().toString();
 +        assertEquals(temp, "Index1");
 +      }
 +      
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +   
 +  }
 +
 +  @Test
 +  public void testIndexUsageWithOrderBy2() throws Exception
 +  {
 +    QueryService qs;
 +    qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    
 +    int numObjects = 30;
 +    // Add some test data now
 +    // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for (int i=0; i < numObjects; i++) {
 +      Portfolio p = new Portfolio(i % 2);
 +      p.createTime = (numObjects - i);
 +      testRgn.put("" + i, p);
 +    }
 +
 +    qs = CacheUtils.getQueryService();
 +    String queries[] = {
 +        "SELECT DISTINCT p.key, p.value FROM /testRgn.entrySet p  WHERE p.value.ID <= 10 order by p.value.createTime asc limit 1",
 +        "SELECT DISTINCT p.key, p.value FROM /testRgn.entrySet p  WHERE p.value.ID <= 10 order by p.value.createTime desc limit 1",
 +    };
 +
 +    Object r[][] = new Object[queries.length][2];
 +
 +    // Execute Queries without Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        // verify individual result
 +        SelectResults sr = (SelectResults)q.execute();
 +        List results = sr.asList();
 +        for (int rows=0; rows < results.size(); rows++) {
 +          Struct s = (Struct)results.get(0);
 +          Portfolio p = (Portfolio)s.get("value");
 +          CacheUtils.getLogger().info("p: " + p);
 +          if (i == 0) {
 +            assertEquals(p.createTime, 1);
 +          } else if (i == 1) {
 +            assertEquals(p.createTime, numObjects);
 +          }
 +        }
 +        r[i][0] = sr;
 +        CacheUtils.log("Executed query: " + queries[i]);
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL, "p.value.ID", "/testRgn.entrySet p");
 + 
 +    // Execute Queries with Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        SelectResults sr = (SelectResults)q.execute();
 +        List results = sr.asList();
 +        for (int rows=0; rows < results.size(); rows++) {
 +          Struct s = (Struct)results.get(0);
 +          Portfolio p = (Portfolio)s.get("value");
 +          CacheUtils.getLogger().info("index p: " + p);
 +          if (i == 0) {
 +            assertEquals(p.createTime, 1);
 +          } else if (i == 1) {
 +            assertEquals(p.createTime, numObjects);
 +          }
 +        }
 +        r[i][1] = sr;
 +        //r[i][1] = q.execute();
 +        CacheUtils.log("Executing query: " + queries[i]
 +            + " with index created");
 +        if (!observer.isIndexesUsed) {
 +          fail("Index is NOT uesd");
 +        }
 +        Iterator itr = observer.indexesUsed.iterator();
 +        assertTrue(itr.hasNext());
 +        String temp = itr.next().toString();
 +        assertEquals(temp, "Index1");
 +      }
 +      
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +    StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +    ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r, queries.length,queries);
 +  }
 +
 +  @Test
 +  public void testIncorrectIndexOperatorSyntax() {
 +    QueryService qs;
 +    qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    int ID =1;
 +    //Add some test data now
 +    //Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for(; ID <=30; ++ID) {
 +      MapKeyIndexData mkid = new MapKeyIndexData(ID);
 +      for(int j =1; j<= ID;++j) {
 +        mkid.maap.put("key1", j*1);
 +        mkid.maap.put("key2", j*2);
 +        mkid.maap.put("key3", j*3);
 +      }
 +      testRgn.put(ID, mkid);
 +    }
 +    
 +    
 +    qs = CacheUtils.getQueryService();
 +    try { 
 +    Query q = CacheUtils.getQueryService().newQuery(
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap[*] >= 3");
 +    fail("Should have thrown exception");
 +    }catch(QueryInvalidException qe) {
 +      //ok      
 +    }           
 +    
 +    try { 
 +    Query q = CacheUtils.getQueryService().newQuery(
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key1','key2'] >= 3");
 +    fail("Should have thrown exception");
 +    }catch(QueryInvalidException qe) {
 +      //ok      
 +    }   
 +      
 +  }
 +  
 +  @Test
 +  public void testRangeGroupingBehaviourOfCompactMapIndex() throws Exception {
 +    QueryService qs;
 +    qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    int ID = 1;
 +    // Add some test data now
 +    // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for (; ID <= 30; ++ID) {
 +      MapKeyIndexData mkid = new MapKeyIndexData(ID);
 +      for (int j = 1; j <= ID; ++j) {
 +        mkid.addKeyValue("key1", j * 1);
 +        mkid.addKeyValue("key2", j * 2);
 +        mkid.addKeyValue("key3", j * 3);
 +      }
 +      testRgn.put(ID, mkid);
 +    }
 +
 +    qs = CacheUtils.getQueryService();
 +    String queries[] = {
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3 and itr1.maap['key2'] <=18",
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key3'] >= 3  and  itr1.maap['key3'] >= 13 ",
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3  and  itr1.maap['key3'] >= 13 ",
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3  and  itr1.maap['key3'] < 18 "
 +        
 +    };
 +
 +
 +    Object r[][] = new Object[queries.length][2];
 +
 +    // Execute Queries without Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        r[i][0] = q.execute();
 +        CacheUtils.log("Executed query: " + queries[i]);
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
 +        "objs.maap['key2','key3']", "/testRgn objs");
 +    assertTrue(i1 instanceof CompactMapRangeIndex);
 +    // Execute Queries with Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        r[i][1] = q.execute();
 +        CacheUtils.log("Executing query: " + queries[i]
 +            + " with index created");
 +        if (!observer.isIndexesUsed) {
 +          fail("Index is NOT uesd");
 +        }
 +        Iterator itr = observer.indexesUsed.iterator();
 +        assertTrue(itr.hasNext());
 +        String temp = itr.next().toString();
 +        assertEquals(temp, "Index1");
 +
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +    StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +    ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r, queries.length,queries);
 +    
 +  }
 +  
 +  @Test
 +  public void testRangeGroupingBehaviourOfMapIndex() throws Exception {
 +    IndexManager.TEST_RANGEINDEX_ONLY = true;
 +    QueryService qs;
 +    qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    int ID = 1;
 +    // Add some test data now
 +    // Add 5 main objects. 1 will contain key1, 2 will contain key1 & key2
 +    // and so on
 +    for (; ID <= 30; ++ID) {
 +      MapKeyIndexData mkid = new MapKeyIndexData(ID);
 +      for (int j = 1; j <= ID; ++j) {
 +        mkid.addKeyValue("key1", j * 1);
 +        mkid.addKeyValue("key2", j * 2);
 +        mkid.addKeyValue("key3", j * 3);
 +      }
 +      testRgn.put(ID, mkid);
 +    }
 +
 +    qs = CacheUtils.getQueryService();
 +    String queries[] = {
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3 and itr1.maap['key2'] <=18",
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key3'] >= 3  and  itr1.maap['key3'] >= 13 ",
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3  and  itr1.maap['key3'] >= 13 ",
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3  and  itr1.maap['key3'] < 18 "
 +        
 +    };
 +
 +
 +    Object r[][] = new Object[queries.length][2];
 +
 +    // Execute Queries without Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        r[i][0] = q.execute();
 +        CacheUtils.log("Executed query: " + queries[i]);
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
 +        "objs.maap['key2','key3']", "/testRgn objs");
 +    assertTrue(i1 instanceof MapRangeIndex);
 +    // Execute Queries with Indexes
 +    for (int i = 0; i < queries.length; i++) {
 +      Query q = null;
 +      try {
 +        q = CacheUtils.getQueryService().newQuery(queries[i]);
 +        CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        r[i][1] = q.execute();
 +        CacheUtils.log("Executing query: " + queries[i]
 +            + " with index created");
 +        if (!observer.isIndexesUsed) {
 +          fail("Index is NOT uesd");
 +        }
 +        Iterator itr = observer.indexesUsed.iterator();
 +        assertTrue(itr.hasNext());
 +        String temp = itr.next().toString();
 +        assertEquals(temp, "Index1");
 +
 +      }
 +      catch (Exception e) {
 +        e.printStackTrace();
 +        fail(q.getQueryString());
 +      }
 +    }
 +    StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +    ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r, queries.length,queries);
 +    
 +  }
 +  
 +  @Test
 +  public void testMapIndexUsableQueryOnEmptyRegion() throws Exception
 +  {
- 
++    IndexManager.TEST_RANGEINDEX_ONLY = true;
 +    QueryService qs;
 +    qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
 +        "objs.maap['key2','key3']", "/testRgn objs");
 +    qs = CacheUtils.getQueryService();
 +    // Execute Queries without Indexes
 +    Query q = CacheUtils.getQueryService().newQuery(
 +        "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.maap['key2'] >= 3 ");
 +    SelectResults sr = (SelectResults)q.execute();
 +    assertTrue(sr.isEmpty());
 +
 +  }
 +
 +  @Test
 +  public void testSizeEstimateLTInRangeIndexForNullMap() throws Exception {
 +    QueryService qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    //Create indexes
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
 +        "p.status", "/testRgn p, p.positions");
 +    Index i2 = qs.createIndex("Index2", IndexType.FUNCTIONAL,
 +        "p.ID", "/testRgn p, p.positions");
 +    
 +    //put values
 +    testRgn.put(0, new Portfolio(0));
 +    testRgn.put(1, new Portfolio(1));
 +
 +    //Set TestHook in RangeIndex
 +    TestHook hook = new RangeIndexTestHook();
 +    RangeIndex.setTestHook(hook);
 +    // Execute Queries without Indexes
 +    Query q = CacheUtils.getQueryService().newQuery(
 +        "<trace> SELECT * FROM /testRgn p, p.positions where p.status = 'active' AND p.ID > 0 ");
 +    
 +    //Following should throw NullPointerException.
 +    SelectResults sr = (SelectResults)q.execute();
 +    
 +    assertTrue("RangeIndexTestHook was not hooked for spot 2", ((RangeIndexTestHook)hook).isHooked(2));
 +    RangeIndex.setTestHook(null);
 +  }
 +
 +  @Test
 +  public void testSizeEstimateGTInRangeIndexForNullMap() throws Exception {
 +    QueryService qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    //Create indexes
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
 +        "p.status", "/testRgn p, p.positions");
 +    Index i2 = qs.createIndex("Index2", IndexType.FUNCTIONAL,
 +        "p.ID", "/testRgn p, p.positions");
 +    
 +    //put values
 +    testRgn.put(0, new Portfolio(0));
 +    testRgn.put(1, new Portfolio(1));
 +
 +    //Set TestHook in RangeIndex
 +    TestHook hook = new RangeIndexTestHook();
 +    RangeIndex.setTestHook(hook);
 +    // Execute Queries without Indexes
 +    Query q = CacheUtils.getQueryService().newQuery(
 +        "<trace> SELECT * FROM /testRgn p, p.positions where p.status = 'active' AND p.ID < 0 ");
 +    
 +    //Following should throw NullPointerException.
 +    SelectResults sr = (SelectResults)q.execute();
 +    
 +    assertTrue("RangeIndexTestHook was not hooked for spot 1", ((RangeIndexTestHook)hook).isHooked(1));
 +    RangeIndex.setTestHook(null);
 +  }
 +
 +  @Test
 +  public void testSizeEstimateLTInCompactRangeIndexForNullMap() throws Exception {
 +    QueryService qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    //Create indexes
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
 +        "p.status", "/testRgn p");
 +    Index i2 = qs.createIndex("Index2", IndexType.FUNCTIONAL,
 +        "p.ID", "/testRgn p");
 +    
 +    //put values
 +    testRgn.put(0, new Portfolio(0));
 +    testRgn.put(1, new Portfolio(1));
 +
 +    //Set TestHook in RangeIndex
 +    TestHook hook = new RangeIndexTestHook();
 +    CompactRangeIndex.setTestHook(hook);
 +    // Execute Queries without Indexes
 +    Query q = CacheUtils.getQueryService().newQuery(
 +        "<trace> SELECT * FROM /testRgn p where p.status = 'active' AND p.ID > 0 ");
 +    
 +    //Following should throw NullPointerException.
 +    SelectResults sr = (SelectResults)q.execute();
 +    
 +    assertTrue("RangeIndexTestHook was not hooked for spot 2", ((RangeIndexTestHook)hook).isHooked(2));
 +    CompactRangeIndex.setTestHook(null);
 +  }
 +
 +  @Test
 +  public void testSizeEstimateGTInCompactRangeIndexForNullMap() throws Exception {
 +    QueryService qs = CacheUtils.getQueryService();
 +    LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +    //Create indexes
 +    Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL,
 +        "p.status", "/testRgn p");
 +    Index i2 = qs.createIndex("Index2", IndexType.FUNCTIONAL,
 +        "p.ID", "/testRgn p");
 +    
 +    //put values
 +    testRgn.put(0, new Portfolio(0));
 +    testRgn.put(1, new Portfolio(1));
 +
 +    //Set TestHook in RangeIndex
 +    TestHook hook = new RangeIndexTestHook();
 +    CompactRangeIndex.setTestHook(hook);
 +    // Execute Queries without Indexes
 +    Query q = CacheUtils.getQueryService().newQuery(
 +        "<trace> SELECT * FROM /testRgn p where p.status = 'active' AND p.ID < 0 ");
 +    
 +    //Following should throw NullPointerException.
 +    SelectResults sr = (SelectResults)q.execute();
 +    
 +    assertTrue("RangeIndexTestHook was not hooked for spot 1", ((RangeIndexTestHook)hook).isHooked(1));
 +    CompactRangeIndex.setTestHook(null);
 +  }
 +  
 +  @Test
 +  public void testCompactMapIndexUsageAllKeysWithVariousValueTypes() throws Exception {
 +      QueryService qs;
 +      qs = CacheUtils.getQueryService();
 +      LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +      int ID =1;
 +      for(; ID <=30; ++ID) {
 +        TestObject object = new TestObject(ID);
 +        testRgn.put(ID, object);
 +      }
 +      String queries[] = {
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['string'] = '1'",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['double'] > 1D",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['integer'] > 1",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['long'] > 1L"
 +      };
 +      String queriesIndexNotUsed[] = {        
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('string') = '1'",       
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('double') > 1D",         
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('integer') > 1",         
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('long') > 1L"         
 +       };
-       Object r[][]= new Object[queries.length][2];
-       
-       qs = CacheUtils.getQueryService();
-       
-     //Execute Queries without Indexes
-       for (int i = 0; i < queries.length; i++) {
-           Query q = null;
-           try {
-               q = CacheUtils.getQueryService().newQuery(queries[i]);
-               CacheUtils.getLogger().info("Executing query: " + queries[i]);              
-               r[i][0] = q.execute();         
-             CacheUtils.log("Executed query: " + queries[i] );
-           } catch (Exception e) {
-               e.printStackTrace();
-               fail(q.getQueryString());
-           }
-       }  
-       
-       Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL, "itr1.testFields[*]",
-           "/testRgn itr1");
-       
-       assertTrue(i1 instanceof CompactMapRangeIndex);
-       
-             //Execute Queries with Indexes
-         for (int i = 0; i < queries.length; i++) {
-             Query q = null;
-             try {
-                 q = CacheUtils.getQueryService().newQuery(queries[i]);
-                 CacheUtils.getLogger().info("Executing query: " + queries[i]);
-                 QueryObserverImpl observer = new QueryObserverImpl();
-                 QueryObserverHolder.setInstance(observer);
-                 r[i][1] = q.execute();
-                 CacheUtils.log("Executing query: " + queries[i] + " with index created");
-                 if(!observer.isIndexesUsed){
-                     fail("Index is NOT uesd");
-                 }              
-                 Iterator itr = observer.indexesUsed.iterator();
-                 assertTrue(itr.hasNext());
-                 String temp = itr.next().toString();
-                 assertEquals(temp,"Index1");       
-                 
-             } catch (Exception e) {
-                 e.printStackTrace();
-                 fail(q.getQueryString());
-             }
-         }
-         StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
-         ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r,queries.length,queries);
-         
-         //Test queries index not used
-         for (int i = 0; i < queriesIndexNotUsed.length; i++) {
-           Query q = null;
-           try {
-               q = CacheUtils.getQueryService().newQuery(queriesIndexNotUsed[i]);
-               CacheUtils.getLogger().info("Executing query: " + queriesIndexNotUsed[i]);
-               QueryObserverImpl observer = new QueryObserverImpl();
-               QueryObserverHolder.setInstance(observer);            
-               CacheUtils.log("Executing query: " + queriesIndexNotUsed[i] + " with index created");
-               q.execute();
-               assertFalse(observer.isIndexesUsed);                          
-               Iterator itr = observer.indexesUsed.iterator();
-               assertFalse(itr.hasNext());                   
-               
-           } catch (Exception e) {
-               e.printStackTrace();
-               fail(q.getQueryString());
-           }
-       }
++      this.evaluateMapTypeIndexUsage("itr1.testFields[*]", "/testRgn itr1", queries, queriesIndexNotUsed, CompactMapRangeIndex.class);
 +    }
 +    
 +    @Test
 +  public void testCompactMapIndexUsageAllKeysOneIndex() throws Exception {
 +      QueryService qs;
 +      qs = CacheUtils.getQueryService();
 +      LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +      int ID =1;
 +      for(; ID <=30; ++ID) {
 +        TestObject object = new TestObject(ID);
 +        testRgn.put(ID, object);
 +      }
 +      String queries[] = {
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['string'] = '1'",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['double'] > 1D",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['integer'] > 1",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['long'] > 1L"
 +      };
 +      String queriesIndexNotUsed[] = {        
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('string') = '1'",       
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('double') > 1D",         
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('integer') > 1",         
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('long') > 1L"         
 +       };
-       Object r[][]= new Object[queries.length][2];
-       
-       qs = CacheUtils.getQueryService();
-       
-     //Execute Queries without Indexes
-       for (int i = 0; i < queries.length; i++) {
-           Query q = null;
-           try {
-               q = CacheUtils.getQueryService().newQuery(queries[i]);
-               CacheUtils.getLogger().info("Executing query: " + queries[i]);              
-               r[i][0] = q.execute();         
-             CacheUtils.log("Executed query: " + queries[i] );
-           } catch (Exception e) {
-               e.printStackTrace();
-               fail(q.getQueryString());
-           }
-       }  
-       
-       Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL, "itr1.testFields['string','double','integer','long']",
-           "/testRgn itr1");
-       
-       assertTrue(i1 instanceof CompactMapRangeIndex);
-       
-             //Execute Queries with Indexes
-         for (int i = 0; i < queries.length; i++) {
-             Query q = null;
-             try {
-                 q = CacheUtils.getQueryService().newQuery(queries[i]);
-                 CacheUtils.getLogger().info("Executing query: " + queries[i]);
-                 QueryObserverImpl observer = new QueryObserverImpl();
-                 QueryObserverHolder.setInstance(observer);
-                 r[i][1] = q.execute();
-                 CacheUtils.log("Executing query: " + queries[i] + " with index created");
-                 if(!observer.isIndexesUsed){
-                     fail("Index is NOT uesd");
-                 }              
-                 Iterator itr = observer.indexesUsed.iterator();
-                 assertTrue(itr.hasNext());
-                 String temp = itr.next().toString();
-                 assertEquals(temp,"Index1");       
-                 
-             } catch (Exception e) {
-                 e.printStackTrace();
-                 fail(q.getQueryString());
-             }
-         }
-         StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
-         ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r,queries.length,queries);
-         
-         //Test queries index not used
-         for (int i = 0; i < queriesIndexNotUsed.length; i++) {
-           Query q = null;
-           try {
-               q = CacheUtils.getQueryService().newQuery(queriesIndexNotUsed[i]);
-               CacheUtils.getLogger().info("Executing query: " + queriesIndexNotUsed[i]);
-               QueryObserverImpl observer = new QueryObserverImpl();
-               QueryObserverHolder.setInstance(observer);            
-               CacheUtils.log("Executing query: " + queriesIndexNotUsed[i] + " with index created");
-               q.execute();
-               assertFalse(observer.isIndexesUsed);                          
-               Iterator itr = observer.indexesUsed.iterator();
-               assertFalse(itr.hasNext());                   
-               
-           } catch (Exception e) {
-               e.printStackTrace();
-               fail(q.getQueryString());
-           }
-       }
++     evaluateMapTypeIndexUsage("itr1.testFields['string','double','integer','long']", "/testRgn itr1", queries, queriesIndexNotUsed, CompactMapRangeIndex.class);
 +    }
 +    
 +    @Test
 +  public void testCompactMapIndexUsageManyGetKeysWithVariousValueTypes() throws Exception {
 +      QueryService qs;
 +      qs = CacheUtils.getQueryService();
 +      LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +      int ID =1;
 +      for(; ID <=30; ++ID) {
 +        TestObject object = new TestObject(ID);
 +        testRgn.put(ID, object);
 +      }
 +      String queries[] = {
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('string') = '1'",       
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('double') > 1D",         
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('integer') > 1",         
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('long') > 1L" 
 +      };
 +      String queriesIndexNotUsed[] = {        
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['string'] = '1'",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['double'] > 1D",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['integer'] > 1",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['long'] > 1L"
 +       };
 +      Object r[][]= new Object[queries.length][2];
 +      
 +      qs = CacheUtils.getQueryService();
 +      
 +      //Execute Queries without Indexes
 +      for (int i = 0; i < queries.length; i++) {
 +          Query q = null;
 +          try {
 +              q = CacheUtils.getQueryService().newQuery(queries[i]);
 +              CacheUtils.getLogger().info("Executing query: " + queries[i]);              
 +              r[i][0] = q.execute();         
 +            CacheUtils.log("Executed query: " + queries[i] );
 +          } catch (Exception e) {
 +              e.printStackTrace();
 +              fail(q.getQueryString());
 +          }
 +      }  
 +      
 +      Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL, "itr1.testFields.get('string')",
 +          "/testRgn itr1");
 +      Index i2 = qs.createIndex("Index2", IndexType.FUNCTIONAL, "itr1.testFields.get('double')",
 +          "/testRgn itr1");
 +      Index i3 = qs.createIndex("Index3", IndexType.FUNCTIONAL, "itr1.testFields.get('integer')",
 +          "/testRgn itr1");
 +      Index i4 = qs.createIndex("Index4", IndexType.FUNCTIONAL, "itr1.testFields.get('long')",
 +          "/testRgn itr1");  
 +      Index i5 = qs.createIndex("Index5", IndexType.FUNCTIONAL, "itr1.testFields.get('complex')",
 +          "/testRgn itr1");
 +      
 +      assertTrue(i1 instanceof CompactRangeIndex);
 +      
 +            //Execute Queries with Indexes
 +        for (int i = 0; i < queries.length; i++) {
 +            Query q = null;
 +            try {
 +                q = CacheUtils.getQueryService().newQuery(queries[i]);
 +                CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +                QueryObserverImpl observer = new QueryObserverImpl();
 +                QueryObserverHolder.setInstance(observer);
 +                r[i][1] = q.execute();
 +                CacheUtils.log("Executing query: " + queries[i] + " with index created");
 +                if(!observer.isIndexesUsed){
 +                    fail("Index is NOT uesd");
 +                }              
 +                Iterator itr = observer.indexesUsed.iterator();
 +                assertTrue(itr.hasNext());
 +                String temp = itr.next().toString();
 +                assertEquals(temp,"Index" + (i + 1));       
 +                
 +            } catch (Exception e) {
 +                e.printStackTrace();
 +                fail(q.getQueryString());
 +            }
 +        }
 +        StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +        ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r,queries.length,queries);
 +        
 +        //Test queries index not used
 +        for (int i = 0; i < queriesIndexNotUsed.length; i++) {
 +          Query q = null;
 +          try {
 +              q = CacheUtils.getQueryService().newQuery(queriesIndexNotUsed[i]);
 +              CacheUtils.getLogger().info("Executing query: " + queriesIndexNotUsed[i]);
 +              QueryObserverImpl observer = new QueryObserverImpl();
 +              QueryObserverHolder.setInstance(observer);            
 +              CacheUtils.log("Executing query: " + queriesIndexNotUsed[i] + " with index created");
 +              q.execute();
 +              assertFalse(observer.isIndexesUsed);                          
 +              Iterator itr = observer.indexesUsed.iterator();
 +              assertFalse(itr.hasNext());                   
 +              
 +          } catch (Exception e) {
 +              e.printStackTrace();
 +              fail(q.getQueryString());
 +          }
 +      }
 +    }
 +    
 +    @Test
 +  public void testCompactMapIndexUsageManyKeysWithVariousValueTypes() throws Exception {
 +      QueryService qs;
 +      qs = CacheUtils.getQueryService();
 +      LocalRegion testRgn = (LocalRegion)CacheUtils.createRegion("testRgn", null);
 +      int ID =1;
 +      for(; ID <=30; ++ID) {
 +        TestObject object = new TestObject(ID);
 +        testRgn.put(ID, object);
 +      }
 +      String queries[] = {
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['string'] = '1'",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['double'] > 1D",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['integer'] > 1",
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields['long'] > 1L"
 +      };
 +      String queriesIndexNotUsed[] = {        
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('string') = '1'",       
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('double') > 1D",         
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('integer') > 1",         
 +          "SELECT DISTINCT * FROM /testRgn itr1  WHERE itr1.testFields.get('long') > 1L"         
 +       };
 +      Object r[][]= new Object[queries.length][2];
 +      
 +      qs = CacheUtils.getQueryService();
 +      
 +    //Execute Queries without Indexes
 +      for (int i = 0; i < queries.length; i++) {
 +          Query q = null;
 +          try {
 +              q = CacheUtils.getQueryService().newQuery(queries[i]);
 +              CacheUtils.getLogger().info("Executing query: " + queries[i]);              
 +              r[i][0] = q.execute();         
 +            CacheUtils.log("Executed query: " + queries[i] );
 +          } catch (Exception e) {
 +              e.printStackTrace();
 +              fail(q.getQueryString());
 +          }
 +      }  
 +      
 +      Index i1 = qs.createIndex("Index1", IndexType.FUNCTIONAL, "itr1.testFields['string']",
 +          "/testRgn itr1");
 +      Index i2 = qs.createIndex("Index2", IndexType.FUNCTIONAL, "itr1.testFields['double']",
 +          "/testRgn itr1");
 +      Index i3 = qs.createIndex("Index3", IndexType.FUNCTIONAL, "itr1.testFields['integer']",
 +          "/testRgn itr1");
 +      Index i4 = qs.createIndex("Index4", IndexType.FUNCTIONAL, "itr1.testFields['long']",
 +          "/testRgn itr1");
 +      Index i5 = qs.createIndex("Index5", IndexType.FUNCTIONAL, "itr1.testFields['complex']",
 +          "/testRgn itr1");
 +      
 +      assertTrue(i1 instanceof CompactRangeIndex);
 +      
 +            //Execute Queries with Indexes
 +        for (int i = 0; i < queries.length; i++) {
 +            Query q = null;
 +            try {
 +                q = CacheUtils.getQueryService().newQuery(queries[i]);
 +                CacheUtils.getLogger().info("Executing query: " + queries[i]);
 +                QueryObserverImpl observer = new QueryObserverImpl();
 +                QueryObserverHolder.setInstance(observer);
 +                r[i][1] = q.execute();
 +                CacheUtils.log("Executing query: " + queries[i] + " with index created");
 +                if(!observer.isIndexesUsed){
 +                    fail("Index is NOT uesd");
 +                }              
 +                Iterator itr = observer.indexesUsed.iterator();
 +                assertTrue(itr.hasNext());
 +                String temp = itr.next().toString();
 +                assertEquals(temp,"Index" + (i+1));       
 +                
 +            } catch (Exception e) {
 +                e.printStackTrace();
 +                fail(q.getQueryString());
 +            }
 +        }
 +        StructSetOrResultsSet ssOrrs = new StructSetOrResultsSet();
 +        ssOrrs.CompareQueryResultsWithoutAndWithIndexes(r,queries.length,queries);
 +        
 +        //Test queries index not used
 +        for (int i = 0; i < queriesIndexNotUsed.length; i++) {
 +          Query q = null;
 +          try {
 +              q = CacheUtils.getQueryService().newQuery(queriesIndexNotUsed[i]);
 +              CacheUtils.getLogger().info("Executing query: " + queriesIndexNotUsed[i]);
 +              QueryObserverImpl observer = new QueryObserverImpl();
 +              QueryObserverHolder.setInstance(observer);            
 +              CacheUtils.log("Executing query: " + queriesIndexNotUsed[i] + " with index created");
 +              q.execute();
 +              assertFalse(observer.isIndexesUsed);                          
 +              Iterator itr = observer.indexesUsed.iterator();
 +              assertFalse(itr.hasNext());                   
 +              
 +          } catch (Exception e) {
 +              e.printStackTrace();
 +              fail(q.getQueryString());
 +          }
 +      }
 +    }
 +
 +    @Test
 +  public void testIndexUseSelfJoin() throws Exception {
 +      String[] queries = {"SELECT DISTINCT * FROM /pos p1, /pos p2 where p1.status = p2.status",
 +          "SELECT DISTINCT * FROM /pos p1, /pos p2 where p1.ID = p2.ID",
 +          "SELECT DISTINCT * FROM /pos p1, /pos p2 where p1.P1.secId = p2.P1.secId",
 +          "SELECT DISTINCT * FROM /pos p1, /pos p2 where p1.status = p2.status and p1.status = 'active'",
 +          "SELECT DISTINCT * FROM /pos p1, /pos p2 where p1.ID = p2.ID and p1.ID < 2",
 +          "SELECT * FROM /pos p1, /pos p2 where p1.ID = p2.ID",
 +          "SELECT * FROM /pos p1, /pos p2 where p1.P1.secId = p2.P1.secId",
 +          "SELECT * FROM /pos p1, /pos p2 where p1.status = p2.status and p1.status = 'active'",
 +          "SELECT * FROM /pos p1, /pos p2 where p1.ID = p2.ID and p1.ID < 2"};
 +
 +      SelectResults[][] sr = new SelectResults[queries.length][2];
 +        for (int j = 0; j < queries.length; j++) {
 +          Query q = qs.newQuery(queries[j]);
 +          QueryObserverImpl observer = new QueryObserverImpl();
 +          QueryObserverHolder.setInstance(observer);
 +          sr[j][0] = (SelectResults) q.execute();
 +          if(sr[j][0].size() == 0) {
 +            fail("Query " + q.getQueryString() + " should have returned results");
 +          }
 +          if (!observer.isIndexesUsed) {
 +            fail("Index should have been used for query '" + q.getQueryString() + "'");
 +          }
 +        }
 +        qs.removeIndexes();
 +        for (int j = 0; j < queries.length; j++) {
 +          Query q = qs.newQuery(queries[j]);
 +          QueryObserverImpl observer = new QueryObserverImpl();
 +          QueryObserverHolder.setInstance(observer);
 +          sr[j][1] = (SelectResults) q.execute();
 +          if(sr[j][1].size() == 0) {
 +            fail("Query " + q.getQueryString() + " should have returned results");
 +          }
 +          if (observer.isIndexesUsed) {
 +            fail("Index should not be used for query '" + q.getQueryString() + "'");
 +          }
 +        }
 +        CacheUtils.compareResultsOfWithAndWithoutIndex(sr);
 +    }
 +
 +    @Test
-   public void testUndefinedInResults() throws Exception {
++  public void testUndefinedResultsAreReturnedWhenANotEqualsQueryIsExecuted() throws Exception {
 +      Portfolio p1 = new Portfolio(0);
 +      p1.position1 = null;
 +      region.put("0", p1);
 +      Portfolio p2 = new Portfolio(2);
 +      p2.position1 = null;
 +      region.put("2", p2);
 +
 +      String query = "SELECT p.position1.secId FROM /pos p where p.position1.secId != 'MSFT' ";
 +      SelectResults[][] sr = new SelectResults[1][2];
 +      sr[0][0] = (SelectResults) qs.newQuery(query).execute();
 +      qs.removeIndexes();
 +      sr[0][1] = (SelectResults) qs.newQuery(query).execute();
 +      if(!CacheUtils.compareResultsOfWithAndWithoutIndex(sr)) {
 +        fail("Query results not same with and without index");
 +      }
 +    }
 +
 +    @Test
-     public void testBug52444() throws Exception {
++    public void testIndexesRemainInUseAfterARebalance() throws Exception {
 +        // Create partitioned region
 +        PartitionAttributesFactory paf = new PartitionAttributesFactory();
 +        AttributesFactory af = new AttributesFactory();
 +        af.setPartitionAttributes(paf.create());
-         Region region = CacheUtils.createRegion("testBug52444", af.create(), false);
++        Region region = CacheUtils.createRegion("testIndexesRemainInUseAfterARebalance", af.create(), false);
 +
 +        // Add index
 +        PartitionedIndex index = (PartitionedIndex) qs.createIndex("statusIndex", "status", region.getFullPath());
 +
 +        // Do puts
 +        for (int i=0; i<200; i++) {
 +          region.put(i, new Portfolio(i));
 +        }
 +        
 +        // Initialize query observer
 +        QueryObserverImpl observer = new QueryObserverImpl();
 +        QueryObserverHolder.setInstance(observer);
 +        
 +        // Create and run query
 +        Query query = qs.newQuery("SELECT * FROM " + region.getFullPath() + " where status = 'active'");
 +        query.execute();
 +
 +        // Verify index was used
 +        assertTrue(observer.isIndexesUsed);
 +
 +        // Get the first index entry in the PartitionedIndex bucketIndexes and delete the index from it (to simulate what happens when a bucket is moved)
 +        Map.Entry<Region,List<Index>> firstIndexEntry = index.getFirstBucketIndex();
 +        assertTrue(!firstIndexEntry.getValue().isEmpty());
 +        index.removeFromBucketIndexes(firstIndexEntry.getKey(), firstIndexEntry.getValue().iterator().next());
 +        
 +        // Verify the index was removed from the entry and the entry was removed from the bucket indexes
 +        assertTrue(firstIndexEntry.getValue().isEmpty());      
 +        Map.Entry<Region,List<Index>> nextFirstIndexEntry = index.getFirstBucketIndex();
 +        assertTrue(!nextFirstIndexEntry.getValue().isEmpty());
 +        
 +        // Run query again
 +        observer.reset();
 +        query.execute();
 +        
 +        // Verify index was still used
 +        assertTrue(observer.isIndexesUsed);
 +      }
++    
++  @Test
++  public void testPKIndexUseWithPR() throws Exception {
++    evaluatePKIndexUsetest(RegionShortcut.PARTITION, "pkTest");
++  }
++
++  @Test
++  public void testPKIndexUseWithReplicate() throws Exception {
++    evaluatePKIndexUsetest(RegionShortcut.REPLICATE, "pkTest");
++  }
++    
++  private void evaluatePKIndexUsetest(RegionShortcut regionShortcut, String regionName) throws Exception {
++    Cache cache = CacheUtils.getCache();
++    Region r = cache.createRegionFactory(regionShortcut).create(regionName);
++    Map map0 = new HashMap();
++    Map map1 = new HashMap();
++    Map map2 = new HashMap();
++    r.put("A0", map0);
++    r.put("A1", map1);
++    r.put("A2", map2);
++    qs.createIndex("pkIndex", IndexType.PRIMARY_KEY, "p.pk", "/" + regionName + " p");
++    QueryObserverImpl observer = new QueryObserverImpl();
++    QueryObserverHolder.setInstance(observer);
++    SelectResults sr = (SelectResults) qs.newQuery("select * from /" + regionName + " p where p.pk = 'A1'").execute();
++    assertEquals(1, sr.size());
++
++    if (!observer.isIndexesUsed) {
++      fail("Index not used for operator '='");
++    }
++  }
 +
 +  class QueryObserverImpl extends QueryObserverAdapter
 +  {
 +    boolean isIndexesUsed = false;
 +
 +    ArrayList indexesUsed = new ArrayList();
 +
 +    public void beforeIndexLookup(Index index, int oper, Object key) {
 +      indexesUsed.add(index.getName());
 +    }
 +
 +    public void afterIndexLookup(Collection results) {
 +      if (results != null) {
 +        isIndexesUsed = true;
 +      }
 +    }
 +    
 +    public void reset() {
 +      this.isIndexesUsed = false;
 +      this.indexesUsed.clear();
 +    }
 +  }
 +  
 +  public class RangeIndexTestHook implements TestHook {
 +
 +    int lastHook = -1;
 +    @Override
 +    public void hook(int spot) throws RuntimeException {
 +      lastHook = spot;
 +      CacheUtils.getCache().getLogger().fine("Inside RangeIndexTestHook for spot "+ spot);
 +      if (spot == 1) { //LT size estimate
 +        CacheUtils.getCache().getRegion("testRgn").clear();
 +      } else if (spot == 2) { //GT size estimate
 +        CacheUtils.getCache().getRegion("testRgn").clear();
 +      }
 +    }
 +
 +    public boolean isHooked(int spot) {
 +      return spot==lastHook;
 +    }
 +  }
 +  static  class MapKeyIndexData {
 +    int id;
 +    public Map maap = new HashMap();
 +    public List liist = new ArrayList();
 +    public MapKeyIndexData(int id) {
 +      this.id = id;
 +    }
 +    public void addKeyValue(Object key, Object value) {
 +      this.maap.put(key,value);
 +      this.liist.add(value);
 +    }
 +  }
 +  private class TestObject {
 +      public Map testFields = new HashMap();
 +      TestObject(int i) {
 +        testFields.put("string", "String Value" + i);
 +        testFields.put("double", (double) i);
 +        testFields.put("integer", i);
 +        testFields.put("long", (long) i);
 +        testFields.put("complex", new CompObject(i));
 +      }
 +      public Map getTestFields() {
 +        return testFields;
 +      }
 +    }
 +    
 +    private class CompObject implements Comparable {
 +      int value;
 +      CompObject(int i) {
 +        value = i;
 +      }
 +      
 +      
 +      public int compareTo(Object o) {
 +        if (o instanceof CompObject) {
 +          CompObject other = (CompObject) o;
 +          if (value > other.value) {
 +            return 1;
 +          }
 +          else if (value == other.value){
 +            return 0;
 +          }
 +          else {
 +            return -1;
 +          }
 +        }
 +        throw new ClassCastException("Could not cast " + o.getClass().getName() + " to compObject");
 +      }
 +      
 +    }
 +
 +}


Mime
View raw message