address review comments

h2/src/main/org/h2/command/dml/Select.java

@@ -187,9 +187,7 @@ public class Select extends Query {
     public void setCurrentGroupExprData(Expression expr, Object obj) {
         Integer index = exprToIndexInGroupByData.get(expr);
         if (index != null) {
-            if (currentGroupByExprData[index] != null) {
-                throw DbException.throwInternalError();
-            }
+            assert currentGroupByExprData[index] != null;
             currentGroupByExprData[index] = obj;
             return;
         }
@@ -368,6 +366,7 @@ public class Select extends Query {
         currentGroupByExprData = null;
         currentGroupsKey = null;
         exprToIndexInGroupByData.clear();
+        try {
             int rowNumber = 0;
             setCurrentRowNumber(0);
             ValueArray defaultGroup = ValueArray.get(new Value[0]);
@@ -407,7 +406,8 @@ public class Select extends Query {
                 }
             }
             if (groupIndex == null && groupByData.size() == 0) {
-            groupByData.put(defaultGroup, new Object[Math.max(exprToIndexInGroupByData.size(), expressions.size())]);
+                groupByData.put(defaultGroup,
+                        new Object[Math.max(exprToIndexInGroupByData.size(), expressions.size())]);
             }
             ArrayList<Value> keys = groupByData.keys();
             for (Value v : keys) {
@@ -431,11 +431,13 @@ public class Select extends Query {
                 row = keepOnlyDistinct(row, columnCount);
                 result.addRow(row);
             }
+        } finally {
             groupByData = null;
             currentGroupsKey = null;
             currentGroupByExprData = null;
             exprToIndexInGroupByData.clear();
         }
+    }
 
     /**
      * Get the index that matches the ORDER BY list, if one exists. This is to

h2/src/main/org/h2/util/ValueHashMap.java

@@ -19,14 +19,13 @@ import org.h2.value.ValueNull;
  * <p>
  * HashMap in archaic versions of Java have some overhead for allocation of
  * entries, but slightly better behaviour with limited number of collisions,
- * because collisions have no impact on non-colliding entires. HashMap in modern
+ * because collisions have no impact on non-colliding entries. HashMap in modern
  * versions of Java also have the same overhead, but it builds a trees of keys
  * with colliding hashes, that's why even if the all keys have exactly the same
  * hash code it still offers a good performance similar to TreeMap. So
  * ValueHashMap is faster in typical cases, but may behave really bad in some
  * cases. HashMap is slower in typical cases, but its performance does not
- * degrade too much even in the worst possible case (if keys are comparable,
- * like our Value class).
+ * degrade too much even in the worst possible case (if keys are comparable).
  *
  * @param <V> the value type
  */