geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kl...@apache.org
Subject [46/50] [abbrv] geode git commit: GEODE-2632: change dependencies on GemFireCacheImpl to InternalCache
Date Thu, 11 May 2017 21:23:52 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIn.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIn.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIn.java
index 0aa1efb..2532f19 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIn.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIn.java
@@ -12,7 +12,6 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-
 package org.apache.geode.cache.query.internal;
 
 import java.lang.reflect.Array;
@@ -50,13 +49,6 @@ import org.apache.geode.internal.i18n.LocalizedStrings;
 import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.pdx.internal.PdxString;
 
-/**
- * Class Description
- *
- * @version $Revision: 1.1 $
- */
-
-
 public class CompiledIn extends AbstractCompiledValue implements Indexable {
   private static final Logger logger = LogService.getLogger();
 
@@ -80,7 +72,7 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     return LITERAL_in;
   }
 
-  /*
+  /**
    * We retrieve the collection from the context cache if it exists This allows us to not have to
    * reevaluate the sub query on every iteration. This improves performance for queries such as
    * "select * from /receipts r where r.type = 'large' and r.id in (select c.id from /customers c
@@ -118,7 +110,7 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     }
 
     if (evalColln instanceof Collection) {
-      Iterator iterator = ((Collection) evalColln).iterator();
+      Iterator iterator = ((Iterable) evalColln).iterator();
       while (iterator.hasNext()) {
         Object evalObj = evalElm;
         Object collnObj = iterator.next();
@@ -158,15 +150,16 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     return Boolean.FALSE;
   }
 
-  // Asif: If the size of aray is two this implies that it is
-  // a relation ship index & so the key field will be null in both the indexes
-  // as key is not a meaningful entity. The 0th element will refer to LHS
-  // operand
-  // and 1th element will refer to RHS operannd
+  /**
+   * If the size of aray is two this implies that it is a relation ship index & so the key field
+   * will be null in both the indexes as key is not a meaningful entity. The 0th element will refer
+   * to LHS operand and 1th element will refer to RHS operannd
+   */
   public IndexInfo[] getIndexInfo(ExecutionContext context)
       throws TypeMismatchException, AmbiguousNameException, NameResolutionException {
     IndexInfo[] indexInfo = privGetIndexInfo(context);
     if (indexInfo != null) {
+      // TODO: == check is identity only
       if (indexInfo == NO_INDEXES_IDENTIFIER) {
         return null;
       } else {
@@ -181,7 +174,7 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     if (pAndK != null) {
       CompiledValue path = pAndK._path;
       CompiledValue indexKey = pAndK._key;
-      IndexData indexData = QueryUtils.getAvailableIndexIfAny(path, context, this.TOK_EQ);
+      IndexData indexData = QueryUtils.getAvailableIndexIfAny(path, context, TOK_EQ);
       IndexProtocol index = null;
       if (indexData != null) {
         index = indexData.getIndex();
@@ -189,7 +182,7 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
       if (index != null && index.isValid()) {
         newIndexInfo = new IndexInfo[1];
         newIndexInfo[0] = new IndexInfo(indexKey, path, index, indexData.getMatchLevel(),
-            indexData.getMapping(), this.TOK_EQ);
+            indexData.getMapping(), TOK_EQ);
       }
     }
     if (newIndexInfo != null) {
@@ -200,9 +193,9 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     return newIndexInfo;
   }
 
-
-  // _indexInfo is a transient field
-  // if this is just faulted in then can be null
+  /**
+   * _indexInfo is a transient field if this is just faulted in then can be null
+   */
   private IndexInfo[] privGetIndexInfo(ExecutionContext context) {
     return (IndexInfo[]) context.cacheGet(this);
   }
@@ -211,7 +204,9 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     context.cachePut(this, indexInfo);
   }
 
-  // Invariant: the receiver is dependent on the current iterator.
+  /**
+   * Invariant: the receiver is dependent on the current iterator.
+   */
   protected PlanInfo protGetPlanInfo(ExecutionContext context)
       throws TypeMismatchException, AmbiguousNameException, NameResolutionException {
     PlanInfo result = new PlanInfo();
@@ -342,8 +337,7 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
    */
   private PathAndKey getPathAndKey(ExecutionContext context)
       throws TypeMismatchException, AmbiguousNameException {
-    // RuntimeIterator lIter = context.findRuntimeIterator(_left);
-    // RuntimeIterator rIter = context.findRuntimeIterator(_right);
+
     boolean isLeftDependent = context.isDependentOnCurrentScope(this.elm);
     boolean isRightDependent = context.isDependentOnCurrentScope(this.colln);
     if (!isLeftDependent || isRightDependent)
@@ -352,15 +346,14 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     CompiledValue path;
     path = this.elm;
     indexKey = this.colln;
-    // Asif Do not worry about the nature of the collection. As long as it
+    // Do not worry about the nature of the collection. As long as it
     // is not dependent on the current scope we should be fine
 
     return new PathAndKey(path, indexKey);
   }
 
-
   /**
-   * Asif : Evaluates as a filter taking advantage of indexes if appropriate. This function has a
+   * Evaluates as a filter taking advantage of indexes if appropriate. This function has a
    * meaningful implementation only in CompiledComparison & CompiledUndefined . It is unsupported in
    * other classes. The additional parameters which it takes are a boolean which is used to indicate
    * whether the index result set needs to be expanded to the top level or not. The second is a
@@ -378,10 +371,9 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
       QueryInvocationTargetException {
     // see if we're dependent on the current iterator
     // if not let super handle it
-    // RuntimeIterator itr = context.getCurrentIterator();
-    // Support.Assert(itr != null);
-    if (!isDependentOnCurrentScope(context))
+    if (!isDependentOnCurrentScope(context)) {
       return super.filterEvaluate(context, intermediateResults);
+    }
     IndexInfo[] idxInfo = getIndexInfo(context);
     Support.Assert(idxInfo != null,
         "a comparison that is dependent, not indexed, and filter evaluated is not possible");
@@ -396,15 +388,6 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     return TOK_EQ;
   }
 
-  /**
-   * **************** PRIVATE METHODS **************************
-   * 
-   * @throws QueryInvocationTargetException
-   * @throws NameResolutionException
-   * @throws FunctionDomainException
-   * @throws TypeMismatchException
-   */
-
   private void queryIndex(Object key, IndexInfo indexInfo, SelectResults results,
       CompiledValue iterOperands, RuntimeIterator[] indpndntItrs, ExecutionContext context,
       List projAttrib, boolean conditioningNeeded) throws TypeMismatchException,
@@ -419,17 +402,14 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
         indexInfo._getIndex(), 0, null, indexInfo._operator());
     context.cachePut(CompiledValue.INDEX_INFO, contextIndexInfo);
     indexInfo._index.query(key, TOK_EQ, results, !conditioningNeeded ? iterOperands : null,
-        indpndntItrs == null ? null : indpndntItrs[0], context, projAttrib, null, false); // is
-                                                                                          // Intersection
-
-
-
+        indpndntItrs == null ? null : indpndntItrs[0], context, projAttrib, null, false);
   }
 
   /**
    * evaluate as a filter, involving a single iterator. Use an index if possible.
+   *
+   * Invariant: the receiver is dependent on the current iterator.
    */
-  // Invariant: the receiver is dependent on the current iterator.
   private SelectResults singleBaseCollectionFilterEvaluate(ExecutionContext context,
       SelectResults intermediateResults, boolean completeExpansionNeeded,
       CompiledValue iterOperands, IndexInfo indexInfo, RuntimeIterator[] indpndntItr,
@@ -447,14 +427,14 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     boolean useLinkedDataStructure = false;
     boolean nullValuesAtStart = true;
     Boolean orderByClause = (Boolean) context.cacheGet(CompiledValue.CAN_APPLY_ORDER_BY_AT_INDEX);
-    if (orderByClause != null && orderByClause.booleanValue()) {
+    if (orderByClause != null && orderByClause) {
       List orderByAttrs = (List) context.cacheGet(CompiledValue.ORDERBY_ATTRIB);
       useLinkedDataStructure = orderByAttrs.size() == 1;
       nullValuesAtStart = !((CompiledSortCriterion) orderByAttrs.get(0)).getCriterion();
     }
 
     List projAttrib = null;
-    // ////////////////////////////////////////////////////////////////
+
     ObjectType projResultType = null;
     if (!conditioningNeeded) {
       projResultType = evalProj ? (ObjectType) context.cacheGet(RESULT_TYPE) : null;
@@ -537,7 +517,6 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
       }
     }
 
-
     QueryObserver observer = QueryObserverHolder.getInstance();
     try {
       Object evalColln = evaluateColln(context);
@@ -568,7 +547,7 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
         // key in the [1]
         // and the evalColln in the [0] position
         if (key instanceof Object[]) {
-          Iterator iterator = ((ResultsSet) ((Object[]) key)[0]).iterator();
+          Iterator iterator = ((Iterable) ((Object[]) key)[0]).iterator();
           while (iterator.hasNext()) {
             this.queryIndex(new Object[] {iterator.next(), ((Object[]) key)[1]}, indexInfo, results,
                 iterOperands, indpndntItr, context, projAttrib, conditioningNeeded);
@@ -597,48 +576,48 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
         } else if (evalColln instanceof long[]) {
           long[] a = (long[]) evalColln;
           for (int i = 0; i < a.length; i++) {
-            this.queryIndex(Long.valueOf(a[i]), indexInfo, results, iterOperands, indpndntItr,
-                context, projAttrib, conditioningNeeded);
+            this.queryIndex(a[i], indexInfo, results, iterOperands, indpndntItr, context,
+                projAttrib, conditioningNeeded);
           }
 
         } else if (evalColln instanceof double[]) {
           double[] a = (double[]) evalColln;
           for (int i = 0; i < a.length; i++) {
-            this.queryIndex(Double.valueOf(a[i]), indexInfo, results, iterOperands, indpndntItr,
-                context, projAttrib, conditioningNeeded);
+            this.queryIndex(a[i], indexInfo, results, iterOperands, indpndntItr, context,
+                projAttrib, conditioningNeeded);
           }
 
         } else if (evalColln instanceof float[]) {
           float[] a = (float[]) evalColln;
           for (int i = 0; i < a.length; i++) {
-            this.queryIndex(new Float(a[i]), indexInfo, results, iterOperands, indpndntItr, context,
+            this.queryIndex(a[i], indexInfo, results, iterOperands, indpndntItr, context,
                 projAttrib, conditioningNeeded);
           }
 
         } else if (evalColln instanceof int[]) {
           int[] a = (int[]) evalColln;
           for (int i = 0; i < a.length; i++) {
-            this.queryIndex(Integer.valueOf(a[i]), indexInfo, results, iterOperands, indpndntItr,
-                context, projAttrib, conditioningNeeded);
+            this.queryIndex(a[i], indexInfo, results, iterOperands, indpndntItr, context,
+                projAttrib, conditioningNeeded);
           }
         } else if (evalColln instanceof short[]) {
           short[] a = (short[]) evalColln;
           for (int i = 0; i < a.length; i++) {
-            this.queryIndex(new Short(a[i]), indexInfo, results, iterOperands, indpndntItr, context,
+            this.queryIndex(a[i], indexInfo, results, iterOperands, indpndntItr, context,
                 projAttrib, conditioningNeeded);
           }
 
         } else if (evalColln instanceof char[]) {
           char[] a = (char[]) evalColln;
           for (int i = 0; i < a.length; i++) {
-            this.queryIndex(new Character(a[i]), indexInfo, results, iterOperands, indpndntItr,
-                context, projAttrib, conditioningNeeded);
+            this.queryIndex(a[i], indexInfo, results, iterOperands, indpndntItr, context,
+                projAttrib, conditioningNeeded);
           }
 
         } else if (evalColln instanceof byte[]) {
           byte[] a = (byte[]) evalColln;
           for (int i = 0; i < a.length; i++) {
-            this.queryIndex(new Byte(a[i]), indexInfo, results, iterOperands, indpndntItr, context,
+            this.queryIndex(a[i], indexInfo, results, iterOperands, indpndntItr, context,
                 projAttrib, conditioningNeeded);
           }
 
@@ -646,12 +625,11 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
           throw new TypeMismatchException(
               "Operand of IN cannot be interpreted as a Comparable Object. Operand is of type ="
                   + evalColln.getClass());
-
         }
       }
 
       if (conditioningNeeded) {
-        results = QueryUtils.getconditionedIndexResults(results, indexInfo, context,
+        results = QueryUtils.getConditionedIndexResults(results, indexInfo, context,
             indexFieldsSize, completeExpansionNeeded, iterOperands, indpndntItr);
       } else {
         if (isIntersection && intermediateResults != null) {
@@ -662,7 +640,6 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     } finally {
       observer.afterIndexLookup(results);
     }
-
   }
 
   public boolean isProjectionEvaluationAPossibility(ExecutionContext context) {
@@ -702,15 +679,13 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
     }
     conditioningNeeded = ich == null || ich.shufflingNeeded;
     return conditioningNeeded;
-
   }
 
-
   /**
    * evaluate as a filter, producing an intermediate result set. This may require iteration if there
-   * is no index available. Asif :The booelan true implies that CompiledComparsion when existing on
-   * its own always requires a Completeexpansion to top level iterators. This flag can get toggled
-   * to false only from inside a GroupJunction
+   * is no index available. The boolean true implies that CompiledComparison when existing on its
+   * own always requires a CompleteExpansion to top level iterators. This flag can get toggled to
+   * false only from inside a GroupJunction
    * 
    * @param intermediateResults if this parameter is provided, and we have to iterate, then iterate
    *        over this result set instead of the entire base collection.
@@ -718,7 +693,7 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
   public SelectResults filterEvaluate(ExecutionContext context, SelectResults intermediateResults)
       throws FunctionDomainException, TypeMismatchException, NameResolutionException,
       QueryInvocationTargetException {
-    // Asif : This function can be invoked only if the where clause contains
+    // This function can be invoked only if the where clause contains
     // a single condition which is CompiledComparison.
     // If a CompiledComparison exists inside a GroupJunction, then it will
     // always
@@ -738,25 +713,22 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
       indpndntItr = (RuntimeIterator) rntmItrs.iterator().next();
     }
 
-    return filterEvaluate(context, intermediateResults, true/*
-                                                             * Complete Expansion needed
-                                                             */, null,
-        indpndntItr != null ? new RuntimeIterator[] {indpndntItr}
-            : null/*
-                   * Asif :It is safe to pass null as the independent iterator to which the
-                   * condition belongs is required only if boolean complete expansion turns out to
-                   * be false, which can happen only in case of CompiledComparison/CompiledUndefined
-                   * called from roupJunction or CompositeGroupJunction
-                   */,
-        true /* is intersection */, this.isConditioningNeededForIndex(indpndntItr, context, true),
-        true);
+    /*
+     * It is safe to pass null as the independent iterator to which the condition belongs is
+     * required only if boolean complete expansion turns out to be false, which can happen only in
+     * case of CompiledComparison/CompiledUndefined called from GroupJunction or
+     * CompositeGroupJunction
+     */
+    return filterEvaluate(context, intermediateResults, true, null,
+        indpndntItr != null ? new RuntimeIterator[] {indpndntItr} : null, true,
+        this.isConditioningNeededForIndex(indpndntItr, context, true), true);
   }
 
-  /*
-   * Asif : This function should never get invoked as now if a CompiledJunction or GroupJunction
-   * contains a single filterable CompiledComparison it should directly call filterEvaluate rather
-   * than auxFilterEvalutae. Overriding this function just for ensuring that auxFilterEvaluate is
-   * not being called by mistake.
+  /**
+   * This function should never get invoked as now if a CompiledJunction or GroupJunction contains a
+   * single filterable CompiledComparison it should directly call filterEvaluate rather than
+   * auxFilterEvalutae. Overriding this function just for ensuring that auxFilterEvaluate is not
+   * being called by mistake.
    */
   public SelectResults auxFilterEvaluate(ExecutionContext context,
       SelectResults intermediateResults) throws FunctionDomainException, TypeMismatchException,
@@ -787,7 +759,7 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
         isThisBetter = thisSize < thatSize;
         break;
       case LITERAL_and:
-        // Asif: Give preference to IN . Is this right? It does not appear . Ideally we need to get
+        // Give preference to IN . Is this right? It does not appear . Ideally we need to get
         // some estimate on Range. This case is possible only in case of RangeJunction
         break;
       case TOK_LE:
@@ -807,15 +779,15 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
       TypeMismatchException, NameResolutionException, QueryInvocationTargetException {
     IndexInfo[] idxInfo = getIndexInfo(context);
     if (idxInfo == null) {
-      // Asif: This implies it is an independent condition. So evaluate it first
-      // in filter operand
+      // This implies it is an independent condition. So evaluate it first in filter operand
       return 0;
     }
     assert idxInfo.length == 1;
     Object key = idxInfo[0].evaluateIndexKey(context);
 
-    if (key != null && key.equals(QueryService.UNDEFINED))
+    if (key != null && key.equals(QueryService.UNDEFINED)) {
       return 0;
+    }
 
     if (context instanceof QueryExecutionContext) {
       QueryExecutionContext qcontext = (QueryExecutionContext) context;
@@ -862,67 +834,58 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
       } else if (evalColln instanceof long[]) {
         long[] a = (long[]) evalColln;
         for (int i = 0; i < a.length; i++) {
-          size +=
-              idxInfo[0]._index.getSizeEstimate(Long.valueOf(a[i]), TOK_EQ, idxInfo[0]._matchLevel);
+          size += idxInfo[0]._index.getSizeEstimate(a[i], TOK_EQ, idxInfo[0]._matchLevel);
         }
 
       } else if (evalColln instanceof double[]) {
         double[] a = (double[]) evalColln;
         for (int i = 0; i < a.length; i++) {
-          size += idxInfo[0]._index.getSizeEstimate(Double.valueOf(a[i]), TOK_EQ,
-              idxInfo[0]._matchLevel);
+          size += idxInfo[0]._index.getSizeEstimate(a[i], TOK_EQ, idxInfo[0]._matchLevel);
         }
 
       } else if (evalColln instanceof float[]) {
         float[] a = (float[]) evalColln;
         for (int i = 0; i < a.length; i++) {
-          size +=
-              idxInfo[0]._index.getSizeEstimate(new Float(a[i]), TOK_EQ, idxInfo[0]._matchLevel);
-
+          size += idxInfo[0]._index.getSizeEstimate(a[i], TOK_EQ, idxInfo[0]._matchLevel);
         }
 
       } else if (evalColln instanceof int[]) {
         int[] a = (int[]) evalColln;
         for (int i = 0; i < a.length; i++) {
-          size += idxInfo[0]._index.getSizeEstimate(Integer.valueOf(a[i]), TOK_EQ,
-              idxInfo[0]._matchLevel);
+          size += idxInfo[0]._index.getSizeEstimate(a[i], TOK_EQ, idxInfo[0]._matchLevel);
         }
       } else if (evalColln instanceof short[]) {
         short[] a = (short[]) evalColln;
         for (int i = 0; i < a.length; i++) {
-          size +=
-              idxInfo[0]._index.getSizeEstimate(new Short(a[i]), TOK_EQ, idxInfo[0]._matchLevel);
-
+          size += idxInfo[0]._index.getSizeEstimate(a[i], TOK_EQ, idxInfo[0]._matchLevel);
         }
 
       } else if (evalColln instanceof char[]) {
         char[] a = (char[]) evalColln;
         for (int i = 0; i < a.length; i++) {
-          size += idxInfo[0]._index.getSizeEstimate(new Character(a[i]), TOK_EQ,
-              idxInfo[0]._matchLevel);
+          size += idxInfo[0]._index.getSizeEstimate(a[i], TOK_EQ, idxInfo[0]._matchLevel);
         }
 
       } else if (evalColln instanceof byte[]) {
         byte[] a = (byte[]) evalColln;
         for (int i = 0; i < a.length; i++) {
-          size += idxInfo[0]._index.getSizeEstimate(new Byte(a[i]), TOK_EQ, idxInfo[0]._matchLevel);
-
+          size += idxInfo[0]._index.getSizeEstimate(a[i], TOK_EQ, idxInfo[0]._matchLevel);
         }
 
       } else {
         throw new TypeMismatchException(
             "Operand of IN cannot be interpreted as a Comparable Object. Operand is of type ="
                 + evalColln.getClass());
-
       }
     }
     return size;
-
   }
 
+  public boolean isRangeEvaluatable() {
+    return false;
+  }
 
-  /* Inner classes for passing stuff around */
-  class PathAndKey {
+  static class PathAndKey {
 
     CompiledValue _path;
     CompiledValue _key;
@@ -932,10 +895,4 @@ public class CompiledIn extends AbstractCompiledValue implements Indexable {
       _key = indexKey;
     }
   }
-
-
-  public boolean isRangeEvaluatable() {
-    return false;
-  }
-
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIndexOperation.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIndexOperation.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIndexOperation.java
index e06937a..f480ebf 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIndexOperation.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIndexOperation.java
@@ -142,7 +142,7 @@ public class CompiledIndexOperation extends AbstractCompiledValue implements Map
 
   // Asif :Function for generating canonicalized expression
   @Override
-  public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+  public void generateCanonicalizedExpression(StringBuilder clauseBuffer, ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
     // Asif: The canonicalization of Index operator will be of
     // the form IterX.getPositions[IterY.a.b.c]

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIteratorDef.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIteratorDef.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIteratorDef.java
index c19bab3..872614d 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIteratorDef.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledIteratorDef.java
@@ -14,20 +14,34 @@
  */
 package org.apache.geode.cache.query.internal;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import org.apache.logging.log4j.Logger;
 
-import org.apache.geode.cache.*;
-import org.apache.geode.cache.query.*;
-import org.apache.geode.cache.query.internal.parse.*;
-import org.apache.geode.cache.query.types.*;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.query.AmbiguousNameException;
+import org.apache.geode.cache.query.FunctionDomainException;
+import org.apache.geode.cache.query.NameResolutionException;
+import org.apache.geode.cache.query.QueryExecutionTimeoutException;
+import org.apache.geode.cache.query.QueryInvocationTargetException;
+import org.apache.geode.cache.query.QueryService;
+import org.apache.geode.cache.query.RegionNotFoundException;
+import org.apache.geode.cache.query.SelectResults;
+import org.apache.geode.cache.query.TypeMismatchException;
+import org.apache.geode.cache.query.internal.parse.OQLLexerTokenTypes;
 import org.apache.geode.cache.query.internal.types.TypeUtils;
+import org.apache.geode.cache.query.types.CollectionType;
+import org.apache.geode.cache.query.types.MapType;
+import org.apache.geode.cache.query.types.ObjectType;
 import org.apache.geode.internal.i18n.LocalizedStrings;
 import org.apache.geode.internal.logging.LogService;
 
-/**
- */
 public class CompiledIteratorDef extends AbstractCompiledValue {
   private static final Logger logger = LogService.getLogger();
 
@@ -83,17 +97,16 @@ public class CompiledIteratorDef extends AbstractCompiledValue {
       }
     }
     rIter = new RuntimeIterator(this, type);
-    // Rahul : generate from clause should take care of bucket region substitution if
+    // generate from clause should take care of bucket region substitution if
     // necessary and then set the definition.
     String fromClause = genFromClause(context);
     rIter.setDefinition(fromClause);
-    /**
-     * Asif : If the type of RunTimeIterator is still ObjectType & if the RuneTimeIterator is
-     * independent of any iterator of the scopes less than or equal to its own scope, we can
-     * evaluate the collection via RuntimeIterator. This will initialize the Collection of
-     * RuntimeIterator , which is OK. The code in RuntimeIterator will be rectified such that the
-     * ElementType of that RuntimeIterator is taken from the collection
-     * 
+    /*
+     * If the type of RunTimeIterator is still ObjectType & if the RuneTimeIterator is independent
+     * of any iterator of the scopes less than or equal to its own scope, we can evaluate the
+     * collection via RuntimeIterator. This will initialize the Collection of RuntimeIterator ,
+     * which is OK. The code in RuntimeIterator will be rectified such that the ElementType of that
+     * RuntimeIterator is taken from the collection
      */
     if (type.equals(TypeUtils.OBJECT_TYPE)
         && !this.isDependentOnAnyIteratorOfScopeLessThanItsOwn(context)) {
@@ -174,8 +187,7 @@ public class CompiledIteratorDef extends AbstractCompiledValue {
     // PR bucketRegion substitution should have already happened
     // at the expression evaluation level
 
-    SelectResults sr = prepareIteratorDef(coll, this.elementType, context);
-    return sr;
+    return prepareIteratorDef(coll, this.elementType, context);
   }
 
   public int getType() {
@@ -200,22 +212,11 @@ public class CompiledIteratorDef extends AbstractCompiledValue {
   }
 
   /**
-   * TODO:Asif : We need to implement the belwo method of computeDependencies Once we come to
-   * implement changes for partitioned region querying, as in that case if first iterator itself is
-   * a Select Query , then ideally we cannot call that CompiledIteratorDef independent ( which will
-   * be the case at present). When we use this commented function we will also need to take care of
+   * TODO: We need to implement the belwo method of computeDependencies Once we come to implement
+   * changes for partitioned region querying, as in that case if first iterator itself is a Select
+   * Query , then ideally we cannot call that CompiledIteratorDef independent ( which will be the
+   * case at present). When we use this commented function we will also need to take care of
    * correctly implementing the function isDependentOnCurrentScope etc functions.
-   * 
-   * public Set computeDependencies(ExecutionContext context) throws TypeMismatchException,
-   * AmbiguousNameException { //Asif : If a CompiledIteratorDef has a collection expression which
-   * boils down to //a CompiledRegion or CompiledBindArgumnet , then its dependency is empty . In
-   * such cases // we will assume that the current CompiledIteratorDef has a dependency on itself.
-   * // This will be required once we start the changes for partitionedRegion Querying //But when we
-   * are doing check of whether the CompiledIteratorDef is dependent on its // own RuntimeIterator
-   * we will still return false. Set set = this.collectionExpr.computeDependencies(context); Set
-   * retSet = null; if(set.isEmpty()){ retSet =
-   * context.addDependency(this,this.getRuntimeIterator(context)); }else { retSet =
-   * context.addDependencies(this, set); } return retSet; }
    */
   @Override
   public Set computeDependencies(ExecutionContext context)
@@ -223,7 +224,7 @@ public class CompiledIteratorDef extends AbstractCompiledValue {
     return context.addDependencies(this, this.collectionExpr.computeDependencies(context));
   }
 
-  // @todo ericz this method is overly complex, duplicating logic already
+  // TODO: this method is overly complex, duplicating logic already
   // in query evaluation itself. It is overly complex ==> It will not be
   // necessary once we have full typing support.
   // There is a limitation here that it assumes that the collectionExpr is some
@@ -296,7 +297,7 @@ public class CompiledIteratorDef extends AbstractCompiledValue {
       res.setModifiable(false);
       return res;
     }
-    // @todo primitive arrays?
+    // TODO: primitive arrays?
     if (obj instanceof Map) {
       if (elementType.equals(TypeUtils.OBJECT_TYPE)) { // if we don't have more
         // specific type info,
@@ -325,29 +326,22 @@ public class CompiledIteratorDef extends AbstractCompiledValue {
 
   String genFromClause(ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
-    StringBuffer sbuff = new StringBuffer();
+    StringBuilder sbuff = new StringBuilder();
     collectionExpr.generateCanonicalizedExpression(sbuff, context);
     return sbuff.toString();
   }
 
-  boolean isDependentOnAnyIterator(ExecutionContext context) {
-    return context.isDependentOnAnyIterator(this);
-  }
-
   /**
    * Checks if the iterator in question is dependent on any other RuntimeIterator of its own or
    * lesser scope.
-   * 
-   * @param context
    */
   boolean isDependentOnAnyIteratorOfScopeLessThanItsOwn(ExecutionContext context) {
-    // Asif : Get the list of all iterators on which the colelction expression
+    // Get the list of all iterators on which the colelction expression
     // is ultimately dependent on
-    // Set indpRitrs = new HashSet();
-    // context.computeUtlimateDependencies(this, indpRitrs);
-    // Asif:If dependent on self then also assume it to be dependent
+
+    // If dependent on self then also assume it to be dependent
     boolean isDep = false;
-    // Asif : Get the list of all iterators on which the colelction expression
+    // Get the list of all iterators on which the colelction expression
     // is dependent on
     Set dependencySet = context.getDependencySet(this, true);
     Iterator itr = dependencySet.iterator();
@@ -360,6 +354,5 @@ public class CompiledIteratorDef extends AbstractCompiledValue {
       }
     }
     return isDep;
-
   }
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLike.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLike.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLike.java
index fc4a843..4930aed 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLike.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLike.java
@@ -16,6 +16,8 @@ package org.apache.geode.cache.query.internal;
 
 import java.util.regex.Pattern;
 
+import org.apache.logging.log4j.Logger;
+
 import org.apache.geode.cache.query.AmbiguousNameException;
 import org.apache.geode.cache.query.FunctionDomainException;
 import org.apache.geode.cache.query.NameResolutionException;
@@ -27,43 +29,40 @@ import org.apache.geode.cache.query.internal.index.IndexManager;
 import org.apache.geode.cache.query.internal.index.IndexProtocol;
 import org.apache.geode.cache.query.internal.index.PrimaryKeyIndex;
 import org.apache.geode.cache.query.internal.parse.OQLLexerTokenTypes;
-import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.apache.geode.internal.logging.LogService;
 import org.apache.geode.pdx.internal.PdxString;
 
-/**
- * 
- *
- */
 public class CompiledLike extends CompiledComparison {
 
-  final static int WILDCARD_PERCENT = 0;
+  private static final Logger logger = LogService.getLogger();
 
-  final static int WILDCARD_UNDERSCORE = 1;
+  private static final int WILDCARD_PERCENT = 0;
 
-  private Object wildcardTypeKey = new Object();
+  private static final int WILDCARD_UNDERSCORE = 1;
 
-  private Object wildcardPositionKey = new Object();
+  private final Object wildcardTypeKey = new Object();
 
-  private Object patternLengthKey = new Object();
+  private final Object wildcardPositionKey = new Object();
 
-  final static String LOWEST_STRING = "";
+  private final Object patternLengthKey = new Object();
 
-  final static char BOUNDARY_CHAR = (char) 255;
+  static final String LOWEST_STRING = "";
 
-  final static char UNDERSCORE = '_';
+  private static final char BOUNDARY_CHAR = (char) 255;
 
-  final static char PERCENT = '%';
+  private static final char UNDERSCORE = '_';
 
-  final static char BACKSLASH = '\\';
+  private static final char PERCENT = '%';
+
+  private static final char BACKSLASH = '\\';
 
   private final CompiledValue var;
 
-  private Object isIndexEvaluatedKey = new Object();
+  private final Object isIndexEvaluatedKey = new Object();
 
-  // private final CompiledBindArgument bindArg;
   private final CompiledValue bindArg;
 
-  public CompiledLike(CompiledValue var, CompiledValue pattern) {
+  CompiledLike(CompiledValue var, CompiledValue pattern) {
     super(var, pattern, OQLLexerTokenTypes.TOK_EQ);
     this.var = var;
     this.bindArg = pattern;
@@ -122,13 +121,7 @@ public class CompiledLike extends CompiledComparison {
   /**
    * Expands the CompiledLike operands based on sargability into multiple CompiledComparisons
    * 
-   * @param context
    * @return The generated CompiledComparisons
-   * @throws AmbiguousNameException
-   * @throws TypeMismatchException
-   * @throws NameResolutionException
-   * @throws FunctionDomainException
-   * @throws QueryInvocationTargetException
    */
   CompiledComparison[] getExpandedOperandsWithIndexInfoSetIfAny(ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException,
@@ -159,9 +152,8 @@ public class CompiledLike extends CompiledComparison {
       }
     }
     if (IndexManager.testHook != null) {
-      if (GemFireCacheImpl.getInstance().getLogger().fineEnabled()) {
-        GemFireCacheImpl.getInstance().getLogger()
-            .fine("IndexManager TestHook is set in getExpandedOperandsWithIndexInfoSetIfAny.");
+      if (logger.isDebugEnabled()) {
+        logger.debug("IndexManager TestHook is set in getExpandedOperandsWithIndexInfoSetIfAny.");
       }
       IndexManager.testHook.hook(12);
     }
@@ -199,13 +191,10 @@ public class CompiledLike extends CompiledComparison {
     return result;
   }
 
-
   /**
    * Breaks down the like predicate (if sargable) into 2 or 3 CompiledComparisons based on the
    * presence of wildcard
    * 
-   * @param var
-   * @param pattern
    * @return The generated CompiledComparisons
    */
   CompiledComparison[] getRangeIfSargable(ExecutionContext context, CompiledValue var,
@@ -285,7 +274,7 @@ public class CompiledLike extends CompiledComparison {
   }
 
   private String getRegexPattern(String pattern) {
-    StringBuffer sb = new StringBuffer();
+    StringBuilder sb = new StringBuilder();
     boolean prevMetaChar = false;
     int len = pattern.length();
 
@@ -376,7 +365,6 @@ public class CompiledLike extends CompiledComparison {
    * Checks if index can be used for Strings with wildcards. Two wild cards are supported % and _.
    * The wildcard could be at any index position of the string.
    * 
-   * @param buffer
    * @return position of wildcard if sargable otherwise -1
    */
   int checkIfSargableAndRemoveEscapeChars(ExecutionContext context, StringBuffer buffer) {
@@ -405,22 +393,6 @@ public class CompiledLike extends CompiledComparison {
     return wildcardPosition;
   }
 
-  /*
-   * @Override public Object evaluate(ExecutionContext context) throws FunctionDomainException,
-   * TypeMismatchException, NameResolutionException, QueryInvocationTargetException { CompiledValue
-   * iterEvaluator = (CompiledValue)context.cacheGet(this.bindArg); if(iterEvaluator == null) {
-   * String pattern = (String)this.bindArg.evaluate(context); CompiledComparison[] cvs =
-   * getRangeIfSargable(this.var, pattern);
-   * 
-   * for (CompiledComparison cp : cvs) { cp.computeDependencies(context);
-   * 
-   * } if(cvs.length ==2 ) { iterEvaluator = new CompiledJunction(cvs,
-   * OQLLexerTokenTypes.LITERAL_and); }else { iterEvaluator = cvs[0]; }
-   * context.cachePut(this.bindArg, iterEvaluator);
-   * 
-   * } return iterEvaluator.evaluate(context); }
-   */
-
   @Override
   public Object evaluate(ExecutionContext context) throws FunctionDomainException,
       TypeMismatchException, NameResolutionException, QueryInvocationTargetException {
@@ -436,8 +408,6 @@ public class CompiledLike extends CompiledComparison {
             "Null values are not supported with LIKE predicate.");
       }
       pattern = Pattern.compile(getRegexPattern(strPattern), Pattern.MULTILINE | Pattern.DOTALL);
-      // GemFireCacheImpl.getInstance().getLogger().fine("### DEBUG : string :" + strPattern + "
-      // pattern :" + pattern.toString());
       context.cachePut(this.bindArg, pattern);
     }
     Object value = this.var.evaluate(context);

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLiteral.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLiteral.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLiteral.java
index 673660c..32c5c4d 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLiteral.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledLiteral.java
@@ -57,7 +57,7 @@ public class CompiledLiteral extends AbstractCompiledValue {
   }
 
   @Override
-  public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+  public void generateCanonicalizedExpression(StringBuilder clauseBuffer, ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException {
     if (_obj == null) {
       clauseBuffer.insert(0, "null");

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledNegation.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledNegation.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledNegation.java
index 3673b9f..0bb8673 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledNegation.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledNegation.java
@@ -65,7 +65,7 @@ public class CompiledNegation extends AbstractCompiledValue {
   }
 
   @Override
-  public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+  public void generateCanonicalizedExpression(StringBuilder clauseBuffer, ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
     clauseBuffer.insert(0, ')');
     _value.generateCanonicalizedExpression(clauseBuffer, context);

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledOperation.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledOperation.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledOperation.java
index f556f2f..e544d8c 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledOperation.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledOperation.java
@@ -289,7 +289,7 @@ public class CompiledOperation extends AbstractCompiledValue {
 
   // Asif :Function for generating from clause
   @Override
-  public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+  public void generateCanonicalizedExpression(StringBuilder clauseBuffer, ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
     // Asif: if the method name starts with getABC & argument list is empty
     // then canonicalize it to aBC

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledPath.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledPath.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledPath.java
index 2c2bc4a..ec7a84a 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledPath.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledPath.java
@@ -156,7 +156,7 @@ public class CompiledPath extends AbstractCompiledValue {
   }
 
   @Override
-  public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+  public void generateCanonicalizedExpression(StringBuilder clauseBuffer, ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
     // Asif: Canonicalize the tail ID. If the tail ID contains
     // something like getX ,convert it into x.

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledRegion.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledRegion.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledRegion.java
index d463d28..83228f3 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledRegion.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledRegion.java
@@ -19,7 +19,6 @@ import org.apache.geode.cache.*;
 import org.apache.geode.cache.query.*;
 import org.apache.geode.cache.Region;
 import org.apache.geode.internal.cache.BucketRegion;
-import org.apache.geode.internal.cache.LocalDataSet;
 import org.apache.geode.internal.cache.PartitionedRegion;
 import org.apache.geode.internal.i18n.LocalizedStrings;
 
@@ -94,7 +93,7 @@ public class CompiledRegion extends AbstractCompiledValue {
   }
 
   @Override
-  public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+  public void generateCanonicalizedExpression(StringBuilder clauseBuffer, ExecutionContext context)
       throws NameResolutionException {
     clauseBuffer.insert(0, regionPath);
     // rahul : changed for running queries on partitioned region.

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSelect.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSelect.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSelect.java
index 0ecc746..fc64d67 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSelect.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSelect.java
@@ -45,15 +45,11 @@ import org.apache.geode.cache.query.internal.types.TypeUtils;
 import org.apache.geode.cache.query.types.CollectionType;
 import org.apache.geode.cache.query.types.ObjectType;
 import org.apache.geode.cache.query.types.StructType;
+import org.apache.geode.internal.cache.InternalCache;
 import org.apache.geode.internal.i18n.LocalizedStrings;
 import org.apache.geode.pdx.PdxInstance;
 import org.apache.geode.pdx.internal.PdxString;
 
-/**
- * Class Description
- * 
- * @version $Revision: 1.2 $
- */
 public class CompiledSelect extends AbstractCompiledValue {
 
   protected List<CompiledSortCriterion> orderByAttrs; // order by attributes: list of CompiledValue
@@ -63,9 +59,9 @@ public class CompiledSelect extends AbstractCompiledValue {
   // 0 is projection name, 1 is the CompiledValue for the expression
   private boolean distinct;
   private boolean count;
-  // Asif: limits the SelectResults by the number specified.
+  // limits the SelectResults by the number specified.
   private CompiledValue limit;
-  // Shobhit: counts the no of results satisfying where condition for
+  // counts the no of results satisfying where condition for
   // count(*) non-distinct queries where no indexes are used.
   private int countStartQueryResult = 0;
 
@@ -177,7 +173,7 @@ public class CompiledSelect extends AbstractCompiledValue {
   public Set computeDependencies(ExecutionContext context)
       throws TypeMismatchException, AmbiguousNameException, NameResolutionException {
     // bind iterators in new scope in order to determine dependencies
-    context.cachePut(scopeID, context.assosciateScopeID());
+    context.cachePut(scopeID, context.associateScopeID());
     context.newScope((Integer) context.cacheGet(scopeID));
     context.pushExecCache((Integer) context.cacheGet(scopeID));
     try {
@@ -240,11 +236,6 @@ public class CompiledSelect extends AbstractCompiledValue {
 
   /**
    * Transforms the group by clause into distinct order by clause, if possible
-   * 
-   * @param context
-   * @throws AmbiguousNameException
-   * @throws TypeMismatchException
-   * @throws NameResolutionException
    */
   private void transformGroupByIfPossible(ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
@@ -268,8 +259,8 @@ public class CompiledSelect extends AbstractCompiledValue {
       }
 
       boolean shouldTransform = true;
-      StringBuffer lhsBuffer = new StringBuffer();
-      StringBuffer rhsBuffer = new StringBuffer();
+      StringBuilder lhsBuffer = new StringBuilder();
+      StringBuilder rhsBuffer = new StringBuilder();
 
       outer: for (int i = 0; i < projAttribs.size(); ++i) {
         Object[] prj = (Object[]) TypeUtils.checkCast(projAttribs.get(i), Object[].class);
@@ -336,7 +327,7 @@ public class CompiledSelect extends AbstractCompiledValue {
       while (iter.hasNext()) {
         CompiledSortCriterion csc = iter.next();
 
-        // Asif: Ideally for replicated regions, the requirement that
+        // Ideally for replicated regions, the requirement that
         // projected columns should
         // contain order by fields ( directly or derivable on it),
         // is not needed. But for PR , the query gathers only projected
@@ -354,9 +345,8 @@ public class CompiledSelect extends AbstractCompiledValue {
     }
   }
 
-
   private void evalCanonicalizedExpressionForCSC(CompiledSortCriterion csc,
-      ExecutionContext context, StringBuffer buffer)
+      ExecutionContext context, StringBuilder buffer)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
     csc.getExpr().generateCanonicalizedExpression(buffer, context);
   }
@@ -370,7 +360,7 @@ public class CompiledSelect extends AbstractCompiledValue {
    * 
    * @return the empty result set of the appropriate type
    */
-  public SelectResults getEmptyResultSet(Object[] parameters, Cache cache, Query query)
+  public SelectResults getEmptyResultSet(Object[] parameters, InternalCache cache, Query query)
       throws FunctionDomainException, TypeMismatchException, NameResolutionException,
       QueryInvocationTargetException {
     ExecutionContext context = new QueryExecutionContext(parameters, cache, query);
@@ -420,10 +410,10 @@ public class CompiledSelect extends AbstractCompiledValue {
         CompiledIteratorDef iterDef = (CompiledIteratorDef) iter.next();
         RuntimeIterator rIter = iterDef.getRuntimeIterator(context);
         context.bindIterator(rIter);
-        // Asif . Ideally the function below should always be called after binding has occurred
-        // So that the interal ID gets set during binding to the scope. If not so then chances
-        // are that internal_id is still null causing index_interanl_id to be null.
-        // Though in our case it may not be an issue as the compute depedency phase must have
+        // Ideally the function below should always be called after binding has occurred
+        // So that the internal ID gets set during binding to the scope. If not so then chances
+        // are that internal_id is still null causing index_internal_id to be null.
+        // Though in our case it may not be an issue as the compute dependency phase must have
         // already set the index id
       }
       Integer limitValue = evaluateLimitValue(context, this.limit);
@@ -453,7 +443,7 @@ public class CompiledSelect extends AbstractCompiledValue {
             throw new TypeMismatchException(
                 LocalizedStrings.CompiledSelect_THE_WHERE_CLAUSE_WAS_TYPE_0_INSTEAD_OF_BOOLEAN
                     .toLocalizedString(b.getClass().getName()));
-          } else if (((Boolean) b).booleanValue()) {
+          } else if ((Boolean) b) {
             result = doIterationEvaluate(context, false);
           } else {
             result = prepareEmptyResultSet(context, false);
@@ -466,7 +456,7 @@ public class CompiledSelect extends AbstractCompiledValue {
           // If order by clause is defined, then the first column should be the preferred index
           if (this.orderByAttrs != null && numInd == 1) {
             CompiledSortCriterion csc = (CompiledSortCriterion) orderByAttrs.get(0);
-            StringBuffer preferredIndexCondn = new StringBuffer();
+            StringBuilder preferredIndexCondn = new StringBuilder();
             this.evalCanonicalizedExpressionForCSC(csc, context, preferredIndexCondn);
             context.cachePut(PREF_INDEX_COND, preferredIndexCondn.toString());
           }
@@ -497,9 +487,9 @@ public class CompiledSelect extends AbstractCompiledValue {
                   && ((Filter) this.whereClause).isLimitApplicableAtIndexLevel(context)) {
                 context.cachePut(CAN_APPLY_LIMIT_AT_INDEX, Boolean.TRUE);
               }
-              StringBuffer temp = null;
+              StringBuilder temp = null;
               if (this.orderByAttrs != null) {
-                temp = new StringBuffer();
+                temp = new StringBuilder();
                 CompiledSortCriterion csc = (CompiledSortCriterion) this.orderByAttrs.get(0);
                 this.evalCanonicalizedExpressionForCSC(csc, context, temp);
               }
@@ -562,7 +552,7 @@ public class CompiledSelect extends AbstractCompiledValue {
           }
         }
       }
-      // TODO:Asif: It does not appear that results would be null ever.
+      // TODO: It does not appear that results would be null ever.
       // if (result == null) { return QueryService.UNDEFINED; }
       assert result != null;
       // drop duplicates if this is DISTINCT
@@ -617,7 +607,7 @@ public class CompiledSelect extends AbstractCompiledValue {
             result = countResult;
 
           } else {
-            ((ResultsBag) res).addAndGetOccurence(countStartQueryResult);
+            ((Bag) res).addAndGetOccurence(countStartQueryResult);
           }
         }
       }
@@ -632,9 +622,6 @@ public class CompiledSelect extends AbstractCompiledValue {
    * The index is locked during query to prevent it from being removed by another thread. So we have
    * to release the lock only after whole query is finished as one query can use an index multiple
    * times.
-   * 
-   * 
-   * @param planInfo
    */
   private void releaseReadLockOnUsedIndex(PlanInfo planInfo) {
     List inds = planInfo.indexes;
@@ -649,12 +636,9 @@ public class CompiledSelect extends AbstractCompiledValue {
     }
   }
 
-
   /**
-   * Retruns the size of region iterator for count(*) on a region without whereclause.
+   * Returns the size of region iterator for count(*) on a region without whereclause.
    * 
-   * @param collExpr
-   * @throws RegionNotFoundException
    * @since GemFire 6.6.2
    */
   private int getRegionIteratorSize(ExecutionContext context, CompiledValue collExpr)
@@ -693,7 +677,7 @@ public class CompiledSelect extends AbstractCompiledValue {
 
     SelectResults results = prepareEmptyResultSet(context, false);
 
-    // TODO:Asif: SELF : Work on limit implementation on bulk get
+    // TODO: SELF : Work on limit implementation on bulk get
     // check for bulk get optimization
     if (evaluateWhereClause) {
       List tmpResults = optimizeBulkGet(context);
@@ -713,13 +697,13 @@ public class CompiledSelect extends AbstractCompiledValue {
     int numElementsInResult = 0;
     try {
       doNestedIterations(0, results, context, evaluateWhereClause, numElementsInResult);
-    } catch (CompiledSelect.NullIteratorException cnie) {
+    } catch (CompiledSelect.NullIteratorException ignore) {
       return null;
     }
     return results;
   }
 
-  // @todo make this more general to work for any kind of map, not just regions
+  // TODO: make this more general to work for any kind of map, not just regions
   /**
    * Check for the bulk-get pattern and if it applies do an optimized execution. The pattern is:
    * SELECT ?? FROM <Region>.entrySet e WHERE e.key IN <Collection>.
@@ -790,11 +774,11 @@ public class CompiledSelect extends AbstractCompiledValue {
         if (result == null) {
           addToResults = false;
         } else if (result instanceof Boolean) {
-          addToResults = ((Boolean) result).booleanValue();
+          addToResults = (Boolean) result;
         } else if (result == QueryService.UNDEFINED) {
           // add UNDEFINED to results only for NOT EQUALS queries
           if (this.whereClause.getType() == COMPARISON) {
-            int operator = ((CompiledComparison) this.whereClause).getOperator();
+            int operator = ((Filter) this.whereClause).getOperator();
             if ((operator != TOK_NE && operator != TOK_NE_ALT)) {
               addToResults = false;
             }
@@ -810,12 +794,12 @@ public class CompiledSelect extends AbstractCompiledValue {
       if (addToResults) {
         int occurence =
             applyProjectionAndAddToResultSet(context, results, this.orderByAttrs == null);
-        // Asif: If the occurence is greater than 1, then only in case of
+        // If the occurence is greater than 1, then only in case of
         // non distinct query should it be treated as contributing to size
         // else duplication will be eliminated when making it distinct using
         // ResultsCollectionWrapper and we will fall short of limit
         if (occurence == 1 || (occurence > 1 && !this.distinct)) {
-          // Asif: (Unique i.e first time occurence) or subsequent occurence
+          // (Unique i.e first time occurence) or subsequent occurence
           // for non distinct query
           ++numElementsInResult;
         }
@@ -871,7 +855,7 @@ public class CompiledSelect extends AbstractCompiledValue {
       NameResolutionException, QueryInvocationTargetException {
     List iterators = context.getCurrentIterators();
     if (projAttrs == null && (this.orderByAttrs == null || ignoreOrderBy)) {
-      // Asif : If the projection attribute is null( ie.e specified as *) &
+      // If the projection attribute is null( ie.e specified as *) &
       // there is only one
       // Runtime Iteratir we can return the set as it is.But if the proejction
       // attribute is null & multiple Iterators are defined we need to rectify
@@ -909,7 +893,7 @@ public class CompiledSelect extends AbstractCompiledValue {
           }
           int occurence = applyProjectionAndAddToResultSet(context, pResultSet, ignoreOrderBy);
           if (occurence == 1 || (occurence > 1 && !this.distinct)) {
-            // Asif: (Unique i.e first time occurence) or subsequent occurence
+            // (Unique i.e first time occurence) or subsequent occurence
             // for non distinct query
             ++numElementsAdded;
           }
@@ -925,7 +909,7 @@ public class CompiledSelect extends AbstractCompiledValue {
           rIter.setCurrent(resultsIter.next());
           int occurence = applyProjectionAndAddToResultSet(context, pResultSet, ignoreOrderBy);
           if (occurence == 1 || (occurence > 1 && !this.distinct)) {
-            // Asif: (Unique i.e first time occurence) or subsequent occurence
+            // (Unique i.e first time occurence) or subsequent occurence
             // for non distinct query
             ++numElementsAdded;
           }
@@ -941,7 +925,7 @@ public class CompiledSelect extends AbstractCompiledValue {
 
   private SelectResults prepareEmptyResultSet(ExecutionContext context, boolean ignoreOrderBy)
       throws TypeMismatchException, AmbiguousNameException {
-    // Asif:if no projection attributes or '*'as projection attribute
+    // if no projection attributes or '*'as projection attribute
     // & more than one/RunTimeIterator then create a StrcutSet.
     // If attribute is null or '*' & only one RuntimeIterator then create a
     // ResultSet.
@@ -969,7 +953,7 @@ public class CompiledSelect extends AbstractCompiledValue {
                     context)
                 : new OrderByComparator(this.orderByAttrs, (StructTypeImpl) elementType, context);
             results = this.distinct ? new SortedStructSet(comparator, (StructTypeImpl) elementType)
-                : new SortedStructBag(comparator, (StructTypeImpl) elementType, nullValuesAtStart);
+                : new SortedStructBag(comparator, (StructType) elementType, nullValuesAtStart);
 
           }
         } else {
@@ -1018,7 +1002,7 @@ public class CompiledSelect extends AbstractCompiledValue {
 
   protected ObjectType prepareResultType(ExecutionContext context)
       throws TypeMismatchException, AmbiguousNameException {
-    // Asif:if no projection attributes or '*'as projection attribute
+    // if no projection attributes or '*'as projection attribute
     // & more than one/RunTimeIterator then create a StrcutSet.
     // If attribute is null or '*' & only one RuntimeIterator then create a
     // ResultSet.
@@ -1069,22 +1053,9 @@ public class CompiledSelect extends AbstractCompiledValue {
     return elementType;
   }
 
-  /*
-   * private SelectResults prepareEmptySelectResults(ObjectType elementType, boolean isSorted,
-   * ExecutionContext context) { if (elementType.isStructType()) { if (isSorted) { // sorted struct
-   * return prepareEmptySortedStructSet((StructTypeImpl)elementType); } else { // unsorted struct
-   * return new StructBag((StructType)elementType, context.getCachePerfStats()); } } else { //
-   * non-struct if (isSorted) { // sorted non-struct return
-   * prepareEmptySortedResultSet(elementType); } else { // unsorted non-struct return new
-   * ResultsBag(elementType, context.getCachePerfStats()); } } }
-   */
-
-
-
   /**
-   * Asif: This function should be used to create a StructType for those queries which have * as
+   * This function should be used to create a StructType for those queries which have * as
    * projection attribute (implying null projection attribute) & multiple from clauses
-   * 
    */
   private StructTypeImpl createStructTypeForNullProjection(List currentIterators,
       ExecutionContext context) {
@@ -1112,23 +1083,22 @@ public class CompiledSelect extends AbstractCompiledValue {
       RuntimeIterator rit = context.findRuntimeIterator(cv);
       List pathOnItr = cv.getPathOnIterator(rit, context);
       if (pathOnItr != null) {
-        String path[] = (String[]) pathOnItr.toArray(new String[0]);
+        String path[] = (String[]) pathOnItr.toArray(new String[pathOnItr.size()]);
         ObjectType ot[] = PathUtils.calculateTypesAlongPath(rit.getElementType(), path);
         retType = ot[ot.length - 1];
       }
-    } catch (NameNotFoundException e) {
+    } catch (NameNotFoundException ignore) {
       // Unable to determine the type Of attribute.It will default to
       // ObjectType
     }
     return retType;
   }
 
-
   // resultSet could be a set or a bag (we have set constructor, or there
   // could be a distinct subquery)
   // in future, it would be good to simplify this to always work with a bag
   // (converting all sets to bags) until the end when we enforce distinct
-  // Asif: The number returned indicates the occurence of the data in the SelectResults
+  // The number returned indicates the occurence of the data in the SelectResults
   // Thus if the SelectResults is of type ResultsSet or StructSet
   // then 1 will indicate that data was added to the results & that was the
   // first occurence. For this 0 will indicate that the data was not added
@@ -1138,8 +1108,6 @@ public class CompiledSelect extends AbstractCompiledValue {
   // Currently orderBy is present only for StructSet & ResultSet which are
   // unique object holders. So the occurence for them can be either 0 or 1 only
 
-
-
   private int applyProjectionAndAddToResultSet(ExecutionContext context, SelectResults resultSet,
       boolean ignoreOrderBy) throws FunctionDomainException, TypeMismatchException,
       NameResolutionException, QueryInvocationTargetException {
@@ -1149,7 +1117,7 @@ public class CompiledSelect extends AbstractCompiledValue {
     ObjectType elementType = resultSet.getCollectionType().getElementType();
     boolean isStruct = elementType != null && elementType.isStructType();
 
-    // TODO : Asif : Optimize this condition in some clean way
+    // TODO: Optimize this condition in some clean way
     boolean isLinkedStructure =
         resultSet instanceof Ordered && ((Ordered) resultSet).dataPreordered();
 
@@ -1209,7 +1177,7 @@ public class CompiledSelect extends AbstractCompiledValue {
                 comparator.addEvaluatedSortCriteria(values, context);
                 occurence = ((StructFields) resultSet).addFieldValues(values) ? 1 : 0;
               }
-              // Asif: TODO:Instead of a normal Map containing which holds
+              // TODO:Instead of a normal Map containing which holds
               // StructImpl object
               // use a THashObject with Object[] array hashing stragtegy as we
               // are unnnecessarily
@@ -1274,11 +1242,9 @@ public class CompiledSelect extends AbstractCompiledValue {
                     if (!e.isDestroyed()) {
                       try {
                         values[0] = new CqEntry(e.getKey(), e.getValue());
-                      } catch (EntryDestroyedException ede) {
-                        // Even though isDestory() check is made, the entry
-                        // could
-                        // throw EntryDestroyedException if the value becomes
-                        // null.
+                      } catch (EntryDestroyedException ignore) {
+                        // Even though isDestory() check is made, the entry could throw
+                        // EntryDestroyedException if the value becomes null.
                         add = false;
                       }
                     } else {
@@ -1321,7 +1287,7 @@ public class CompiledSelect extends AbstractCompiledValue {
         if (distinct) {
           if (isStruct) {
             comparator.addEvaluatedSortCriteria(values, context);
-            // Asif: Occurence field is used to identify the corrcet number of
+            // Occurence field is used to identify the corrcet number of
             // iterations
             // required to implement the limit based on the presence or absence
             // of distinct clause
@@ -1401,23 +1367,15 @@ public class CompiledSelect extends AbstractCompiledValue {
       } else if (type == METHOD_INV) {
         name = ((CompiledOperation) projExpr).getMethodName();
       } else {
-        name = new StringBuffer("field$").append(context.nextFieldNum()).toString();
+        name = new StringBuilder("field$").append(context.nextFieldNum()).toString();
         // name = projExpr.toString();
       }
     }
     return name;
   }
 
-
   /**
    * Optimized evaluate for CQ execution.
-   * 
-   * @param context
-   * @return boolean
-   * @throws FunctionDomainException
-   * @throws TypeMismatchException
-   * @throws NameResolutionException
-   * @throws QueryInvocationTargetException
    */
   public boolean evaluateCq(ExecutionContext context) throws FunctionDomainException,
       TypeMismatchException, NameResolutionException, QueryInvocationTargetException {
@@ -1456,7 +1414,7 @@ public class CompiledSelect extends AbstractCompiledValue {
       } else if (b == QueryService.UNDEFINED) {
         // add UNDEFINED to results only for NOT EQUALS queries
         if (this.whereClause.getType() == COMPARISON) {
-          int operator = ((CompiledComparison) this.whereClause).getOperator();
+          int operator = ((Filter) this.whereClause).getOperator();
           if ((operator != TOK_NE && operator != TOK_NE_ALT)) {
             return false;
           } else {
@@ -1466,7 +1424,7 @@ public class CompiledSelect extends AbstractCompiledValue {
           return false;
         }
       } else {
-        return (((Boolean) b).booleanValue());
+        return (Boolean) b;
       }
     } finally {
       context.popExecCache();

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSortCriterion.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSortCriterion.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSortCriterion.java
index 5268b1c..d49b4a5 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSortCriterion.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledSortCriterion.java
@@ -12,10 +12,13 @@
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-
 package org.apache.geode.cache.query.internal;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
 
 import org.apache.geode.cache.CacheException;
 import org.apache.geode.cache.query.AmbiguousNameException;
@@ -28,14 +31,16 @@ import org.apache.geode.cache.query.internal.types.TypeUtils;
 
 /**
  * This class represents a compiled form of sort criterian present in order by clause
- * 
  */
 public class CompiledSortCriterion extends AbstractCompiledValue {
-  // Asif: criterion true indicates descending order
+
+  // criterion true indicates descending order
   private boolean criterion = false;
+
   private CompiledValue expr = null;
+
   int columnIndex = -1;
-  // private String correctedCanonicalizedExpression = null;
+
   private CompiledValue originalCorrectedExpression = null;
 
   @Override
@@ -43,20 +48,13 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
     return Collections.singletonList(this.originalCorrectedExpression);
   }
 
-  /**
-   * @return int
-   */
   public int getType() {
     return SORT_CRITERION;
   }
 
   /**
    * evaluates sort criteria in order by clause
-   * 
-   * @param context
-   * @return Object
    */
-
   public Object evaluate(Object data, ExecutionContext context) {
     Object value = null;
     if (this.columnIndex > 0) {
@@ -74,17 +72,11 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
     try {
       return this.expr.evaluate(context);
     } catch (Exception e) {
+      // TODO: never throw an anonymous inner class
       throw new CacheException(e) {};
     }
-
   }
 
-  /**
-   * concstructor
-   * 
-   * @param criterion
-   * @param cv
-   */
   CompiledSortCriterion(boolean criterion, CompiledValue cv) {
     this.expr = cv;
     this.criterion = criterion;
@@ -103,11 +95,6 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
     return this.columnIndex;
   }
 
-  /*
-   * public String getCorrectedCanonicalizedExpression() { return
-   * this.correctedCanonicalizedExpression; }
-   */
-
   @Override
   public Object evaluate(ExecutionContext context) throws FunctionDomainException,
       TypeMismatchException, NameResolutionException, QueryInvocationTargetException {
@@ -128,7 +115,7 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
   private CompiledValue getReconstructedExpression(String projAttribStr, ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
     List<CompiledValue> expressions = PathUtils.collectCompiledValuesInThePath(expr, context);
-    StringBuffer tempBuff = new StringBuffer();
+    StringBuilder tempBuff = new StringBuilder();
     ListIterator<CompiledValue> listIter = expressions.listIterator(expressions.size());
     while (listIter.hasPrevious()) {
       listIter.previous().generateCanonicalizedExpression(tempBuff, context);
@@ -152,20 +139,20 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
       prevCV = cv;
 
       switch (cv.getType()) {
-        case CompiledOperation.METHOD_INV:
+        case OQLLexerTokenTypes.METHOD_INV:
           reconstruct.add(0, ((CompiledOperation) cv).getArguments());
           reconstruct.add(0, ((CompiledOperation) cv).getMethodName());
           break;
-        case CompiledPath.PATH:
+        case CompiledValue.PATH:
           reconstruct.add(0, ((CompiledPath) cv).getTailID());
           break;
-        case CompiledIndexOperation.TOK_LBRACK:
+        case OQLLexerTokenTypes.TOK_LBRACK:
           reconstruct.add(0, ((CompiledIndexOperation) cv).getExpression());
           break;
         default:
           throw new IllegalStateException("Unexpected CompiledValue in order by clause");
       }
-      reconstruct.add(0, Integer.valueOf(prevCV.getType()));
+      reconstruct.add(0, prevCV.getType());
       cv = expressions.get(++index);
     } while (prevCV != cvToRetainTill);
 
@@ -173,7 +160,7 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
     Iterator<Object> iter = reconstruct.iterator();
     CompiledValue currentValue = ProjectionField.getProjectionField();
     while (iter.hasNext()) {
-      int type = ((Integer) iter.next()).intValue();
+      int type = (Integer) iter.next();
       switch (type) {
         case CompiledValue.PATH:
           currentValue = new CompiledPath(currentValue, (String) iter.next());
@@ -214,7 +201,8 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
       }
       if (!mappedColumn) {
         // the order by expr is not an alias check for path
-        StringBuffer orderByExprBuffer = new StringBuffer(), projAttribBuffer = new StringBuffer();
+        StringBuilder orderByExprBuffer = new StringBuilder(),
+            projAttribBuffer = new StringBuilder();
         expr.generateCanonicalizedExpression(orderByExprBuffer, context);
         final String orderByExprStr = orderByExprBuffer.toString();
         for (int i = 0; i < projAttrs.size(); ++i) {
@@ -243,12 +231,12 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
         RuntimeIterator runtimeIter = (RuntimeIterator) currentIters.get(i);
         if (runtimeIter == rIter) {
           /* this.substituteExpressionWithProjectionField( i); */
-          StringBuffer temp = new StringBuffer();
+          StringBuilder temp = new StringBuilder();
           rIter.generateCanonicalizedExpression(temp, context);
           // this.correctedCanonicalizedExpression = temp.toString();
           /* mappedColumn = true; */
           String projAttribStr = temp.toString();
-          temp = new StringBuffer();
+          temp = new StringBuilder();
           expr.generateCanonicalizedExpression(temp, context);
           String orderbyStr = temp.toString();
           if (projAttribStr.equals(orderbyStr)) {
@@ -277,7 +265,6 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
     public Object evaluate(ExecutionContext context) throws FunctionDomainException,
         TypeMismatchException, NameResolutionException, QueryInvocationTargetException {
       return context.getCurrentProjectionField();
-
     }
 
     @Override
@@ -288,7 +275,5 @@ public class CompiledSortCriterion extends AbstractCompiledValue {
     public static ProjectionField getProjectionField() {
       return singleton;
     }
-
   }
-
 }

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledUndefined.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledUndefined.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledUndefined.java
index 9cce2f2..0a8b129 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledUndefined.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledUndefined.java
@@ -17,7 +17,6 @@ package org.apache.geode.cache.query.internal;
 import java.util.*;
 
 import org.apache.geode.cache.query.*;
-import org.apache.geode.cache.query.internal.IndexInfo;
 import org.apache.geode.cache.query.internal.index.IndexData;
 import org.apache.geode.cache.query.internal.index.IndexProtocol;
 import org.apache.geode.cache.query.internal.index.IndexUtils;
@@ -100,7 +99,7 @@ public class CompiledUndefined extends AbstractCompiledValue implements Negatabl
     } finally {
       observer.afterIndexLookup(set);
     }
-    return QueryUtils.getconditionedIndexResults(set, idxInfo[0], context, indexFieldsSize,
+    return QueryUtils.getConditionedIndexResults(set, idxInfo[0], context, indexFieldsSize,
         completeExpansionNeeded, iterOperands, indpndntItrs);
   }
 
@@ -224,7 +223,7 @@ public class CompiledUndefined extends AbstractCompiledValue implements Negatabl
   }
 
   @Override
-  public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+  public void generateCanonicalizedExpression(StringBuilder clauseBuffer, ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
     clauseBuffer.insert(0, ')');
     _value.generateCanonicalizedExpression(clauseBuffer, context);

http://git-wip-us.apache.org/repos/asf/geode/blob/153db276/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledValue.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledValue.java b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledValue.java
index 9da575d..4747980 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledValue.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/query/internal/CompiledValue.java
@@ -27,56 +27,51 @@ import org.apache.geode.distributed.internal.DistributionConfig;
 import java.util.List;
 import java.util.Set;
 
-/**
- * Class Description
- * 
- * @version $Revision: 1.1 $
- */
 public interface CompiledValue {
 
-  // extra node types: use negative numbers so they don't collide with token
-  // types
-  public final static int COMPARISON = -1;
-  public final static int FUNCTION = -2;
-  public final static int JUNCTION = -3;
-  public final static int LITERAL = -4;
-  public final static int PATH = -5;
-  public final static int CONSTRUCTION = -6;
-  public final static int GROUPJUNCTION = -7;
-  public final static int ALLGROUPJUNCTION = -8;
-  public final static int COMPOSITEGROUPJUNCTION = -10;
-  public final static int RANGEJUNCTION = -11;
-  public final static int NOTEQUALCONDITIONEVALUATOR = -12;
-  public final static int SINGLECONDNEVALUATOR = -13;
-  public final static int DOUBLECONDNRANGEJUNCTIONEVALUATOR = -14;
-  public final static int LIKE = -15;
-  public final static int FIELD = -16;
-  public final static int GROUP_BY_SELECT = -17;
-  public static final int INDEX_RESULT_THRESHOLD_DEFAULT = 100;
-  public static final String INDX_THRESHOLD_PROP_STR =
-      DistributionConfig.GEMFIRE_PREFIX + "Query.INDEX_THRESHOLD_SIZE";
-  public static final String INDEX_INFO = "index_info";
-  public static final int indexThresholdSize =
-      Integer.getInteger(INDX_THRESHOLD_PROP_STR, INDEX_RESULT_THRESHOLD_DEFAULT).intValue();
-  public static final String RESULT_TYPE = "result_type";
-  public static final String PROJ_ATTRIB = "projection";
-  public static final String ORDERBY_ATTRIB = "orderby";
-  public static final IndexInfo[] NO_INDEXES_IDENTIFIER = new IndexInfo[0];
-  public static final String RESULT_LIMIT = "limit";
-  public static final String CAN_APPLY_LIMIT_AT_INDEX = "can_apply_limit_at_index";
-  public static final String CAN_APPLY_ORDER_BY_AT_INDEX = "can_apply_orderby_at_index";
-  public static final String PREF_INDEX_COND = "preferred_index_condition";
-  public static final String QUERY_INDEX_HINTS = "query_index_hints";
-  public static final CompiledValue MAP_INDEX_ALL_KEYS = new AbstractCompiledValue() {
-
+  // extra node types: use negative numbers so they don't collide with token types
+  int COMPARISON = -1;
+  int FUNCTION = -2;
+  int JUNCTION = -3;
+  int LITERAL = -4;
+  int PATH = -5;
+  int CONSTRUCTION = -6;
+  int GROUPJUNCTION = -7;
+  int ALLGROUPJUNCTION = -8;
+  int COMPOSITEGROUPJUNCTION = -10;
+  int RANGEJUNCTION = -11;
+  int NOTEQUALCONDITIONEVALUATOR = -12;
+  int SINGLECONDNEVALUATOR = -13;
+  int DOUBLECONDNRANGEJUNCTIONEVALUATOR = -14;
+  int LIKE = -15;
+  int FIELD = -16;
+  int GROUP_BY_SELECT = -17;
+  int INDEX_RESULT_THRESHOLD_DEFAULT = 100;
+  String INDX_THRESHOLD_PROP_STR = DistributionConfig.GEMFIRE_PREFIX + "Query.INDEX_THRESHOLD_SIZE";
+  String INDEX_INFO = "index_info";
+  int indexThresholdSize =
+      Integer.getInteger(INDX_THRESHOLD_PROP_STR, INDEX_RESULT_THRESHOLD_DEFAULT);
+  String RESULT_TYPE = "result_type";
+  String PROJ_ATTRIB = "projection";
+  String ORDERBY_ATTRIB = "orderby";
+  IndexInfo[] NO_INDEXES_IDENTIFIER = new IndexInfo[0];
+  String RESULT_LIMIT = "limit";
+  String CAN_APPLY_LIMIT_AT_INDEX = "can_apply_limit_at_index";
+  String CAN_APPLY_ORDER_BY_AT_INDEX = "can_apply_orderby_at_index";
+  String PREF_INDEX_COND = "preferred_index_condition";
+  String QUERY_INDEX_HINTS = "query_index_hints";
+
+  CompiledValue MAP_INDEX_ALL_KEYS = new AbstractCompiledValue() {
     @Override
-    public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+    public void generateCanonicalizedExpression(StringBuilder clauseBuffer,
+        ExecutionContext context)
         throws AmbiguousNameException, TypeMismatchException, NameResolutionException {
       throw new QueryInvalidException(
           "* cannot be used with index operator. To use as key for map lookup, "
               + "it should be enclosed in ' '");
     }
 
+    @Override
     public Object evaluate(ExecutionContext context) {
       throw new QueryInvalidException(
           "* cannot be used with index operator. To use as key for map lookup, "
@@ -88,39 +83,39 @@ public interface CompiledValue {
       return super.getReceiver();
     }
 
+    @Override
     public int getType() {
       return OQLLexerTokenTypes.TOK_STAR;
     }
-
   };
 
-  public int getType();
+  int getType();
 
-  public ObjectType getTypecast();
+  ObjectType getTypecast();
 
-  public Object evaluate(ExecutionContext context) throws FunctionDomainException,
-      TypeMismatchException, NameResolutionException, QueryInvocationTargetException;
+  Object evaluate(ExecutionContext context) throws FunctionDomainException, TypeMismatchException,
+      NameResolutionException, QueryInvocationTargetException;
 
-  // returns null if N/A
-  public List getPathOnIterator(RuntimeIterator itr, ExecutionContext context)
+  /**
+   * returns null if N/A
+   */
+  List getPathOnIterator(RuntimeIterator itr, ExecutionContext context)
       throws TypeMismatchException, AmbiguousNameException;
 
-  public PlanInfo getPlanInfo(ExecutionContext context) throws FunctionDomainException,
+  PlanInfo getPlanInfo(ExecutionContext context) throws FunctionDomainException,
       TypeMismatchException, NameResolutionException, QueryInvocationTargetException;
 
-  public Set computeDependencies(ExecutionContext context)
+  Set computeDependencies(ExecutionContext context)
       throws TypeMismatchException, AmbiguousNameException, NameResolutionException;
 
-  public boolean isDependentOnIterator(RuntimeIterator itr, ExecutionContext context);
+  boolean isDependentOnIterator(RuntimeIterator itr, ExecutionContext context);
 
-  public boolean isDependentOnCurrentScope(ExecutionContext context);
+  boolean isDependentOnCurrentScope(ExecutionContext context);
 
   /**
    * general-purpose visitor (will be used for extracting region path)
    */
-  // public boolean visit(QVisitor visitor);
-  // Asif :Function for generating from clause
-  public void generateCanonicalizedExpression(StringBuffer clauseBuffer, ExecutionContext context)
+  void generateCanonicalizedExpression(StringBuilder clauseBuffer, ExecutionContext context)
       throws AmbiguousNameException, TypeMismatchException, NameResolutionException;
 
   /**
@@ -128,18 +123,17 @@ public interface CompiledValue {
    * object (CompiledRegion). The default implementation is provided in the AbstractCompiledValue &
    * overridden in the CompiledSelect as it can contain multiple iterators
    */
-  public void getRegionsInQuery(Set regionNames, Object[] parameters);
+  void getRegionsInQuery(Set regionNames, Object[] parameters);
 
   /** Get the CompiledValues that this owns */
-  public List getChildren();
+  List getChildren();
 
-  public void visitNodes(NodeVisitor visitor);
+  void visitNodes(NodeVisitor visitor);
 
-  public static interface NodeVisitor {
+  interface NodeVisitor {
     /** @return true to continue or false to stop */
-    public boolean visit(CompiledValue node);
+    boolean visit(CompiledValue node);
   }
 
-  public CompiledValue getReceiver();
-
+  CompiledValue getReceiver();
 }


Mime
View raw message