class QueryStatisticsData {

    private static final Comparator<QueryEntry> QUERY_ENTRY_COMPARATOR = Comparator
            .comparingLong(q -> q.lastUpdateTime);

    private final HashMap<String, QueryEntry> map = new HashMap<>();

    private int maxQueryEntries;

    public QueryStatisticsData(int maxQueryEntries) {
        this.maxQueryEntries = maxQueryEntries;
    }

    public synchronized void setMaxQueryEntries(int maxQueryEntries) {
        this.maxQueryEntries = maxQueryEntries;
    }

    public synchronized List<QueryEntry> getQueries() {<FILL_FUNCTION_BODY>}

    /**
     * Update query statistics.
     *
     * @param sqlStatement the statement being executed
     * @param executionTimeNanos the time in nanoseconds the query/update took
     *            to execute
     * @param rowCount the query or update row count
     */
    public synchronized void update(String sqlStatement, long executionTimeNanos, long rowCount) {
        QueryEntry entry = map.get(sqlStatement);
        if (entry == null) {
            entry = new QueryEntry(sqlStatement);
            map.put(sqlStatement, entry);
        }
        entry.update(executionTimeNanos, 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
        if (map.size() > maxQueryEntries * 1.5f) {
            // Sort the entries by age
            ArrayList<QueryEntry> list = new ArrayList<>(map.values());
            list.sort(QUERY_ENTRY_COMPARATOR);
            // Create a set of the oldest 1/3 of the entries
            HashSet<QueryEntry> oldestSet = new HashSet<>(list.subList(0, list.size() / 3));
            // 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())) {
                    it.remove();
                }
            }
        }
    }

    /**
     * The collected statistics for one query.
     */
    public static final class QueryEntry {

        /**
         * The SQL statement.
         */
        public final String sqlStatement;

        /**
         * 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 nanoseconds.
         */
        public long executionTimeMinNanos;

        /**
         * The maximum execution time, in nanoseconds.
         */
        public long executionTimeMaxNanos;

        /**
         * The total execution time.
         */
        public long executionTimeCumulativeNanos;

        /**
         * The minimum number of rows.
         */
        public long rowCountMin;

        /**
         * The maximum number of rows.
         */
        public long rowCountMax;

        /**
         * The total number of rows.
         */
        public long rowCountCumulative;

        /**
         * The mean execution time.
         */
        public double executionTimeMeanNanos;

        /**
         * The mean number of rows.
         */
        public double rowCountMean;

        // Using Welford's method, see also
        // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
        // https://www.johndcook.com/blog/standard_deviation/

        private double executionTimeM2Nanos;
        private double rowCountM2;

        public QueryEntry(String sql) {
            this.sqlStatement = sql;
        }

        /**
         * Update the statistics entry.
         *
         * @param timeNanos the execution time in nanos
         * @param rows the number of rows
         */
        void update(long timeNanos, long rows) {
            count++;
            executionTimeMinNanos = Math.min(timeNanos, executionTimeMinNanos);
            executionTimeMaxNanos = Math.max(timeNanos, executionTimeMaxNanos);
            rowCountMin = Math.min(rows, rowCountMin);
            rowCountMax = Math.max(rows, rowCountMax);

            double rowDelta = rows - rowCountMean;
            rowCountMean += rowDelta / count;
            rowCountM2 += rowDelta * (rows - rowCountMean);

            double timeDelta = timeNanos - executionTimeMeanNanos;
            executionTimeMeanNanos += timeDelta / count;
            executionTimeM2Nanos += timeDelta * (timeNanos - executionTimeMeanNanos);

            executionTimeCumulativeNanos += timeNanos;
            rowCountCumulative += rows;
            lastUpdateTime = System.currentTimeMillis();
        }

        public double getExecutionTimeStandardDeviation() {
            // population standard deviation
            return Math.sqrt(executionTimeM2Nanos / count);
        }

        public double getRowCountStandardDeviation() {
            // population standard deviation
            return Math.sqrt(rowCountM2 / count);
        }
    }
}

        // return a copy of the map so we don't have to
        // worry about external synchronization
        ArrayList<QueryEntry> list = new ArrayList<>(map.values());
        // only return the newest 100 entries
        list.sort(QUERY_ENTRY_COMPARATOR);
        return list.subList(0, Math.min(list.size(), maxQueryEntries));
    
<no_super_class>