Formatting / javadocs

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

@@ -219,7 +219,6 @@ public class SetTypes {
      */
     public static final int QUERY_STATISTICS = 41;
 
-    
     private static final ArrayList<String> TYPES = New.arrayList();
 
     private SetTypes() {

h2/src/main/org/h2/engine/QueryStatisticsData.java

@@ -13,7 +13,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
+import java.util.Map.Entry;
 
 /**
  * Maintains query statistics.
@@ -32,7 +32,8 @@ public class QueryStatisticsData {
     private final HashMap<String, QueryEntry> map = new HashMap<String, QueryEntry>();
 
     public synchronized List<QueryEntry> getQueries() {
-        // return a copy of the map so we don't have to worry about external synchronization
+        // return a copy of the map so we don't have to
+        // worry about external synchronization
         ArrayList<QueryEntry> list = new ArrayList<QueryEntry>();
         list.addAll(map.values());
         // only return the newest 100 entries
@@ -51,32 +52,9 @@ public class QueryStatisticsData {
         QueryEntry entry = map.get(sqlStatement);
         if (entry == null) {
             entry = new QueryEntry();
-            entry.sqlStatement = sqlStatement;
-            entry.executionTimeMin = executionTime;
-            entry.executionTimeMax = executionTime;
-            entry.rowCountMin = rowCount;
-            entry.rowCountMax = rowCount;
-            entry.executionTimeMean = executionTime;
-            entry.rowCountMean = rowCount;
             map.put(sqlStatement, entry);
-        } else {
-            entry.count++;
-            entry.executionTimeMin = Math.min(executionTime, entry.executionTimeMin);
-            entry.executionTimeMax = Math.max(executionTime, entry.executionTimeMax);
-            entry.rowCountMin = Math.min(rowCount, entry.rowCountMin);
-            entry.rowCountMax = Math.max(rowCount, entry.rowCountMax);
-            
-            double delta = rowCount - entry.rowCountMean;
-            entry.rowCountMean += delta / entry.count;
-            entry.rowCountM2 += delta * (rowCount - entry.rowCountMean);
-            
-            delta = executionTime - entry.executionTimeMean;
-            entry.executionTimeMean += delta / entry.count;
-            entry.executionTimeM2 += delta * (executionTime - entry.executionTimeMean);
         }
-        entry.executionTimeCumulative += executionTime;        
-        entry.rowCountCumulative += rowCount;
-        entry.lastUpdateTime = System.currentTimeMillis();
+        entry.update(executionTime, rowCount);
 
         // Age-out the oldest entries if the map gets too big.
         // Test against 1.5 x max-size so we don't do this too often
@@ -87,12 +65,12 @@ public class QueryStatisticsData {
             Collections.sort(list, QUERY_ENTRY_COMPARATOR);
             // Create a set of the oldest 1/3 of the entries
             HashSet<QueryEntry> oldestSet = new HashSet<QueryEntry>(list.subList(0, list.size() / 3));
-            // Loop over the map using the set and remove the oldest 1/3 of the
-            // entries.
-            for (Iterator<Map.Entry<String, QueryEntry>> iter = map.entrySet().iterator(); iter.hasNext();) {
-                Map.Entry<String, QueryEntry> mapEntry = iter.next();
+            // Loop over the map using the set and remove
+            // the oldest 1/3 of the entries.
+            for (Iterator<Entry<String, QueryEntry>> it = map.entrySet().iterator(); it.hasNext();) {
+                Entry<String, QueryEntry> mapEntry = it.next();
                 if (oldestSet.contains(mapEntry.getValue())) {
-                    iter.remove();
+                    it.remove();
                 }
             }
         }
@@ -103,24 +81,95 @@ public class QueryStatisticsData {
      */
     public static final class QueryEntry {
 
+        /**
+         * The SQL statement.
+         */
         public String sqlStatement;
 
-        public int count = 1;
+        /**
+         * The number of times the statement was executed.
+         */
+        public int count;
+
+        /**
+         * The last time the statistics for this entry were updated,
+         * in milliseconds since 1970.
+         */
         public long lastUpdateTime;
+
+        /**
+         * The minimum execution time, in milliseconds.
+         */
         public long executionTimeMin;
+
+        /**
+         * The maximum execution time, in milliseconds.
+         */
         public long executionTimeMax;
+
+        /**
+         * The total execution time.
+         */
         public long executionTimeCumulative;
+
+        /**
+         * The minimum number of rows.
+         */
         public int rowCountMin;
+
+        /**
+         * The maximum number of rows.
+         */
         public int rowCountMax;
+
+        /**
+         * The total number of rows.
+         */
         public long rowCountCumulative;
 
+        /**
+         * The mean execution time.
+         */
+        public double executionTimeMean;
+
+        /**
+         * The mean number of rows.
+         */
+        public double rowCountMean;
+
         // Using Welford's method, see also
         // http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
         // http://www.johndcook.com/standard_deviation.html
-        public double executionTimeMean;
-        public double executionTimeM2;
-        public double rowCountMean;
-        public double rowCountM2;
+
+        private double executionTimeM2;
+        private double rowCountM2;
+
+        /**
+         * Update the statistics entry.
+         *
+         * @param time the execution time
+         * @param rows the number of rows
+         */
+        void update(long time, int rows) {
+            count++;
+            executionTimeMin = Math.min(time, executionTimeMin);
+            executionTimeMax = Math.max(time, executionTimeMax);
+            rowCountMin = Math.min(rows, rowCountMin);
+            rowCountMax = Math.max(rows, rowCountMax);
+
+            double delta = rows - rowCountMean;
+            rowCountMean += delta / count;
+            rowCountM2 += delta * (rows - rowCountMean);
+
+            delta = time - executionTimeMean;
+            executionTimeMean += delta / count;
+            executionTimeM2 += delta * (time - executionTimeMean);
+
+            executionTimeCumulative += time;
+            rowCountCumulative += rows;
+            lastUpdateTime = System.currentTimeMillis();
+
+        }
 
         public double getExecutionTimeStandardDeviation() {
             // population standard deviation