cassandra-trunk/src/java/org/apache/cassandra/tools/nodetool/stats/StatsTableComparator.java
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.cassandra.tools.nodetool.stats;

import java.util.Comparator;

import org.apache.cassandra.io.util.FileUtils;

/**
 * Comparator to sort StatsTables by a named statistic.
 */
public class StatsTableComparator implements Comparator<StatsTable>
{

    /**
     * Name of the stat that will be used as the sort key.
     */
    private final String sortKey;

    /**
     * Whether data size stats are printed human readable.
     */
    private final boolean humanReadable;

    /**
     * Whether sorting should be done ascending.
     */
    private final boolean ascending;

    /**
     * Names of supported sort keys as they should be specified on the command line.
     */
    public static final String[] supportedSortKeys = { "average_live_cells_per_slice_last_five_minutes",
                                                       "average_tombstones_per_slice_last_five_minutes",
                                                       "bloom_filter_false_positives", "bloom_filter_false_ratio",
                                                       "bloom_filter_off_heap_memory_used", "bloom_filter_space_used",
                                                       "compacted_partition_maximum_bytes",
                                                       "compacted_partition_mean_bytes",
                                                       "compacted_partition_minimum_bytes",
                                                       "compression_metadata_off_heap_memory_used", "dropped_mutations",
                                                       "full_name", "index_summary_off_heap_memory_used",
                                                       "local_read_count", "local_read_latency_ms",
                                                       "local_write_latency_ms",
                                                       "maximum_live_cells_per_slice_last_five_minutes",
                                                       "maximum_tombstones_per_slice_last_five_minutes",
                                                       "memtable_cell_count", "memtable_data_size",
                                                       "memtable_off_heap_memory_used", "memtable_switch_count",
                                                       "number_of_partitions_estimate", "off_heap_memory_used_total",
                                                       "pending_flushes", "percent_repaired", "read_latency", "reads",
                                                       "space_used_by_snapshots_total", "space_used_live",
                                                       "space_used_total", "sstable_compression_ratio", "sstable_count",
                                                       "table_name", "write_latency", "writes", "max_sstable_size",
                                                       "local_read_write_ratio", "twcs_max_duration"};

    public StatsTableComparator(String sortKey, boolean humanReadable)
    {
        this(sortKey, humanReadable, false);
    }
    
    public StatsTableComparator(String sortKey, boolean humanReadable, boolean ascending)
    {
        this.sortKey = sortKey;
        this.humanReadable = humanReadable;
        this.ascending = ascending;
    }

    /**
     * Compare stats represented as doubles
     */
    private int compareDoubles(double x, double y)
    {
        int sign = ascending ? 1 : -1;
        if (Double.isNaN(x) && !Double.isNaN(y))
            return sign * Double.valueOf(0D).compareTo(Double.valueOf(y));
        else if (!Double.isNaN(x) && Double.isNaN(y))
            return sign * Double.valueOf(x).compareTo(Double.valueOf(0D));
        else if (Double.isNaN(x) && Double.isNaN(y))
            return 0;
        else
            return sign * Double.valueOf(x).compareTo(Double.valueOf(y));
    }

    /**
     * Compare file size stats represented as strings
     */
    private int compareFileSizes(String x, String y)
    {
        int sign = ascending ? 1 : -1;
        if (null == x && null != y)
            return sign * -1;
        else if (null != x && null == y)
            return sign;
        else if (null == x && null == y)
            return 0;
        long sizeX = humanReadable ? FileUtils.parseFileSize(x) : Long.valueOf(x);
        long sizeY = humanReadable ? FileUtils.parseFileSize(y) : Long.valueOf(y);
        return sign * Long.compare(sizeX, sizeY);
    }

    /**
     * Compare StatsTable instances based on this instance's sortKey.
     */
    public int compare(StatsTable stx, StatsTable sty)
    {
        if (stx == null || sty == null)
            throw new NullPointerException("StatsTableComparator cannot compare null objects");
        int sign = ascending ? 1 : -1;
        int result = 0;
        if (sortKey.equals("average_live_cells_per_slice_last_five_minutes"))
        {
            result = compareDoubles(stx.averageLiveCellsPerSliceLastFiveMinutes,
                                    sty.averageLiveCellsPerSliceLastFiveMinutes);
        }
        else if (sortKey.equals("average_tombstones_per_slice_last_five_minutes"))
        {
            result = compareDoubles(stx.averageTombstonesPerSliceLastFiveMinutes,
                                    sty.averageTombstonesPerSliceLastFiveMinutes);
        }
        else if (sortKey.equals("bloom_filter_false_positives"))
        {
            result = sign * ((Long) stx.bloomFilterFalsePositives)
                                    .compareTo((Long) sty.bloomFilterFalsePositives);
        }
        else if (sortKey.equals("bloom_filter_false_ratio"))
        {
            result = compareDoubles((Double) stx.bloomFilterFalseRatio,
                                    (Double) sty.bloomFilterFalseRatio);
        }
        else if (sortKey.equals("bloom_filter_off_heap_memory_used"))
        {
            if (stx.bloomFilterOffHeapUsed && !sty.bloomFilterOffHeapUsed)
                return sign;
            else if (!stx.bloomFilterOffHeapUsed && sty.bloomFilterOffHeapUsed)
                return sign * -1;
            else if (!stx.bloomFilterOffHeapUsed && !sty.bloomFilterOffHeapUsed)
                result = 0;
            else
            {
                result = compareFileSizes(stx.bloomFilterOffHeapMemoryUsed,
                                          sty.bloomFilterOffHeapMemoryUsed);
            }
        }
        else if (sortKey.equals("bloom_filter_space_used"))
        {
            result = compareFileSizes(stx.bloomFilterSpaceUsed,
                                      sty.bloomFilterSpaceUsed);
        }
        else if (sortKey.equals("compacted_partition_maximum_bytes"))
        {
            result = sign * Long.valueOf(stx.compactedPartitionMaximumBytes)
                            .compareTo(Long.valueOf(sty.compactedPartitionMaximumBytes));
        }
        else if (sortKey.equals("compacted_partition_mean_bytes"))
        {
            result = sign * Long.valueOf(stx.compactedPartitionMeanBytes)
                            .compareTo(Long.valueOf(sty.compactedPartitionMeanBytes));
        }
        else if (sortKey.equals("compacted_partition_minimum_bytes"))
        {
            result = sign * Long.valueOf(stx.compactedPartitionMinimumBytes)
                            .compareTo(Long.valueOf(sty.compactedPartitionMinimumBytes));
        }
        else if (sortKey.equals("compression_metadata_off_heap_memory_used"))
        {
            if (stx.compressionMetadataOffHeapUsed && !sty.compressionMetadataOffHeapUsed)
                return sign;
            else if (!stx.compressionMetadataOffHeapUsed && sty.compressionMetadataOffHeapUsed)
                return sign * -1;
            else if (!stx.compressionMetadataOffHeapUsed && !sty.compressionMetadataOffHeapUsed)
                result = 0;
            else
            {
                result = compareFileSizes(stx.compressionMetadataOffHeapMemoryUsed,
                                          sty.compressionMetadataOffHeapMemoryUsed);
            }
        }
        else if (sortKey.equals("dropped_mutations"))
        {
            result = compareFileSizes(stx.droppedMutations, sty.droppedMutations);
        }
        else if (sortKey.equals("full_name"))
        {
            return sign * stx.fullName.compareTo(sty.fullName);
        }
        else if (sortKey.equals("index_summary_off_heap_memory_used"))
        {
            if (stx.indexSummaryOffHeapUsed && !sty.indexSummaryOffHeapUsed)
                return sign;
            else if (!stx.indexSummaryOffHeapUsed && sty.indexSummaryOffHeapUsed)
                return sign * -1;
            else if (!stx.indexSummaryOffHeapUsed && !sty.indexSummaryOffHeapUsed)
                result = 0;
            else
            {
                result = compareFileSizes(stx.indexSummaryOffHeapMemoryUsed,
                                          sty.indexSummaryOffHeapMemoryUsed);
            }
        }
        else if (sortKey.equals("local_read_count") || sortKey.equals("reads"))
        {
            result = sign * Long.valueOf(stx.localReadCount)
                            .compareTo(Long.valueOf(sty.localReadCount));
        }
        else if (sortKey.equals("local_read_latency_ms") || sortKey.equals("read_latency"))
        {
            result = compareDoubles(stx.localReadLatencyMs, sty.localReadLatencyMs);
        }
        else if (sortKey.equals("local_write_count") || sortKey.equals("writes"))
        {
            result = sign * Long.valueOf(stx.localWriteCount)
                            .compareTo(Long.valueOf(sty.localWriteCount));
        }
        else if (sortKey.equals("local_write_latency_ms") || sortKey.equals("write_latency"))
        {
            result = compareDoubles(stx.localWriteLatencyMs, sty.localWriteLatencyMs);
        }
        else if (sortKey.equals("local_read_write_ratio"))
        {
            result = compareDoubles(stx.localReadWriteRatio, sty.localReadWriteRatio);
        }
        else if (sortKey.equals("maximum_live_cells_per_slice_last_five_minutes"))
        {
            result = sign * Long.valueOf(stx.maximumLiveCellsPerSliceLastFiveMinutes)
                            .compareTo(Long.valueOf(sty.maximumLiveCellsPerSliceLastFiveMinutes));
        }
        else if (sortKey.equals("maximum_tombstones_per_slice_last_five_minutes"))
        {
            result = sign * Long.valueOf(stx.maximumTombstonesPerSliceLastFiveMinutes)
                            .compareTo(Long.valueOf(sty.maximumTombstonesPerSliceLastFiveMinutes));
        }
        else if (sortKey.equals("memtable_cell_count"))
        {
            result = sign * ((Long) stx.memtableCellCount)
                                    .compareTo((Long) sty.memtableCellCount); 
        }
        else if (sortKey.equals("memtable_data_size"))
        {
            result = compareFileSizes(stx.memtableDataSize, sty.memtableDataSize);
        }
        else if (sortKey.equals("memtable_off_heap_memory_used"))
        {
            if (stx.memtableOffHeapUsed && !sty.memtableOffHeapUsed)
                return sign;
            else if (!stx.memtableOffHeapUsed && sty.memtableOffHeapUsed)
                return sign * -1;
            else if (!stx.memtableOffHeapUsed && !sty.memtableOffHeapUsed)
                result = 0;
            else
            {
                result = compareFileSizes(stx.memtableOffHeapMemoryUsed,
                                          sty.memtableOffHeapMemoryUsed);
            }
        }
        else if (sortKey.equals("memtable_switch_count"))
        {
            result = sign * ((Long) stx.memtableSwitchCount)
                                    .compareTo((Long) sty.memtableSwitchCount); 
        }
        else if (sortKey.equals("number_of_partitions_estimate"))
        {
            result = sign * ((Long) stx.numberOfPartitionsEstimate)
                                    .compareTo((Long) sty.numberOfPartitionsEstimate);
        }
        else if (sortKey.equals("off_heap_memory_used_total"))
        {
            if (stx.offHeapUsed && !sty.offHeapUsed)
                return sign;
            else if (!stx.offHeapUsed && sty.offHeapUsed)
                return sign * -1;
            else if (!stx.offHeapUsed && !sty.offHeapUsed)
                result = 0;
            else
            {
                result = compareFileSizes(stx.offHeapMemoryUsedTotal,
                                          sty.offHeapMemoryUsedTotal);
            }
        }
        else if (sortKey.equals("pending_flushes"))
        {
            result = sign * ((Long) stx.pendingFlushes)
                                    .compareTo((Long) sty.pendingFlushes);
        }
        else if (sortKey.equals("percent_repaired"))
        {
            result = compareDoubles(stx.percentRepaired, sty.percentRepaired);
        }
        else if (sortKey.equals("max_sstable_size"))
        {
            result = sign * stx.maxSSTableSize.compareTo(sty.maxSSTableSize);
        }
        else if (sortKey.equals("twcs_max_duration"))
        {
            if (stx.twcsDurationInMillis != null && sty.twcsDurationInMillis == null)
                return sign;
            else if (stx.twcsDurationInMillis == null && sty.twcsDurationInMillis != null)
                return sign * -1;
            else if (stx.twcsDurationInMillis == null)
                return 0;
            else
                result = sign * stx.twcsDurationInMillis.compareTo(sty.twcsDurationInMillis);
        }
        else if (sortKey.equals("space_used_by_snapshots_total"))
        {
            result = compareFileSizes(stx.spaceUsedBySnapshotsTotal,
                                      sty.spaceUsedBySnapshotsTotal);
        }
        else if (sortKey.equals("space_used_live"))
        {
            result = compareFileSizes(stx.spaceUsedLive, sty.spaceUsedLive);
        }
        else if (sortKey.equals("space_used_total"))
        {
            result = compareFileSizes(stx.spaceUsedTotal, sty.spaceUsedTotal);
        }
        else if (sortKey.equals("sstable_compression_ratio"))
        {
            result = compareDoubles((Double) stx.sstableCompressionRatio,
                                    (Double) sty.sstableCompressionRatio);
        }
        else if (sortKey.equals("sstable_count"))
        {
            result = sign * ((Integer) stx.sstableCount)
                                       .compareTo((Integer) sty.sstableCount);
        }
        else if (sortKey.equals("table_name"))
        {
            return sign * stx.tableName.compareTo(sty.tableName);
        }
        else
        {
            throw new IllegalStateException(String.format("Unsupported sort key: %s", sortKey));
        }
        return (result == 0) ? stx.fullName.compareTo(sty.fullName) : result;
    }
}
