diff --git a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/Messages.java b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/Messages.java
index 347df74..cd57429 100644
--- a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/Messages.java
+++ b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/Messages.java
@@ -96,6 +96,8 @@
     public static String Column_RetainedHeap;
     public static String Column_ShallowHeap;
 
+    public static String CompareTablesQuery_APPROX;
+
     public static String CompareTablesQuery_Comparing;
     public static String CompareTablesQuery_Initial;
 
@@ -109,11 +111,15 @@
     public static String CompareTablesQuery_DifferenceLast;
     public static String CompareTablesQuery_DifferenceMiddle;
     public static String CompareTablesQuery_DifferenceOf2;
+
+    public static String CompareTablesQuery_GE;
     public static String CompareTablesQuery_IntersectionFirst;
     public static String CompareTablesQuery_IntersectionLast;
     public static String CompareTablesQuery_IntersectionMiddle;
     public static String CompareTablesQuery_IntersectionOf2;
 
+    public static String CompareTablesQuery_LE;
+
     public static String CompareTablesQuery_MissingKeyColumn;
     public static String CompareTablesQuery_Table;
     public static String CompareTablesQuery_SymmetricDifferenceFirst;
diff --git a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/messages.properties b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/messages.properties
index 62aa867..cb3e6e2 100644
--- a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/messages.properties
+++ b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/messages.properties
@@ -75,6 +75,7 @@
 Column_Percentage=Percentage
 Column_RetainedHeap=Retained Heap
 Column_ShallowHeap=Shallow Heap
+CompareTablesQuery_APPROX=\u2248\u0020
 CompareTablesQuery_Comparing=Comparing
 CompareTablesQuery_Initial=Initial comparison
 CompareTablesQuery_InitialComparisonForTable=Initial comparison for table {0}
@@ -105,10 +106,12 @@
 CompareTablesQuery_DifferenceLast={0} and Table {1}
 CompareTablesQuery_DifferenceMiddle={0}, Table {1}
 CompareTablesQuery_DifferenceOf2=Table {0} without Table {1}
+CompareTablesQuery_GE=\u2265\u0020
 CompareTablesQuery_IntersectionFirst=Intersection of Table {0}, Table {1}
 CompareTablesQuery_IntersectionLast={0} and Table {1}
 CompareTablesQuery_IntersectionMiddle={0}, Table {1}
 CompareTablesQuery_IntersectionOf2=Intersection of Table {0} and Table {1}
+CompareTablesQuery_LE=\u2264\u0020
 CompareTablesQuery_MissingKeyColumn=Missing key column {0} for table \#{1}
 CompareTablesQuery_Table=Table {0}
 CompareTablesQuery_SymmetricDifferenceFirst=Symmetric difference of Table {0}, Table {1}
diff --git a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/CompareTablesQuery.java b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/CompareTablesQuery.java
index 216d8bd..e687d33 100644
--- a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/CompareTablesQuery.java
+++ b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/CompareTablesQuery.java
@@ -16,10 +16,14 @@
 import java.io.IOException;
 import java.net.URISyntaxException;
 import java.net.URL;
+import java.text.FieldPosition;
 import java.text.Format;
+import java.text.ParsePosition;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
@@ -54,6 +58,7 @@
 import org.eclipse.mat.query.annotations.Icon;
 import org.eclipse.mat.query.annotations.Menu;
 import org.eclipse.mat.query.annotations.Menu.Entry;
+import org.eclipse.mat.query.refined.Filter;
 import org.eclipse.mat.snapshot.ISnapshot;
 import org.eclipse.mat.snapshot.OQL;
 import org.eclipse.mat.snapshot.model.IObject;
@@ -71,6 +76,8 @@
 @HelpUrl("/org.eclipse.mat.ui.help/tasks/comparingdata.html")
 @Menu({ @Entry(options = "-setop ALL")
 ,@Entry(options = "-mode DIFF_TO_PREVIOUS -prefix -mask \"\\s@ 0x[0-9a-f]+|^\\[[0-9]+\\]$\" -x java.util.HashMap$Node:key java.util.Hashtable$Entry:key java.util.WeakHashMap$Entry:referent java.util.concurrent.ConcurrentHashMap$Node:key")
+,@Entry(options = "-mode DIFF_TO_PREVIOUS -prefix -mask \"\\s@ 0x[0-9a-f]+|^\\[[0-9]+\\]$|(?<=\\p{javaJavaIdentifierPart}\\[)\\d+(?=\\])\" -x java.util.HashMap$Node:key java.util.Hashtable$Entry:key java.util.WeakHashMap$Entry:referent java.util.concurrent.ConcurrentHashMap$Node:key")
+,@Entry(options = "-mode DIFF_TO_PREVIOUS -prefix -mask \"\\s@ 0x[0-9a-f]+|^\\[[0-9]+\\]$|(?<=\\p{javaJavaIdentifierPart}\\[)\\d+(?=\\])\" -x java.util.HashMap$Node:key java.util.Hashtable$Entry:key java.util.WeakHashMap$Entry:referent java.util.concurrent.ConcurrentHashMap$Node:key -setop ALL")
 })
 public class CompareTablesQuery implements IQuery
 {
@@ -175,10 +182,30 @@
         {
             if (i == keyColumn-1)
                 continue;
+            // Check for duplicate column names
+            int prevDuplicateCol = -1;
+            for (int k = 0; k < i - 1; ++k)
+            {
+                if (baseColumns[i].getLabel().equals(baseColumns[k].getLabel()))
+                    prevDuplicateCol = k > keyColumn - 1 ? k - 1 : k; // Adjust for key column
+            }
             int[] indexes = new int[tables.length];
             for (int j = 0; j < indexes.length; j++)
             {
-                indexes[j] = getColumnIndex(baseColumns[i].getLabel(), tables[j]);
+                if (prevDuplicateCol >= 0)
+                {
+                    // Start search after previous found column
+                    int pc = attributes.get(prevDuplicateCol).getColumnIndexes()[j];
+                    int ci = getColumnIndex(baseColumns[i].getLabel(), tables[j], pc + 1);
+                    // Not found, so duplicate the last column
+                    if (ci == -1)
+                        ci = pc;
+                    indexes[j] = ci;
+                }
+                else
+                {
+                    indexes[j] = getColumnIndex(baseColumns[i].getLabel(), tables[j], 0);
+                }
             }
             attributes.add(new ComparedColumn(baseColumns[i], indexes, true));
         }
@@ -188,10 +215,10 @@
                         : new ComparisonResultTable(mergeKeys(null, listener), key, attributes, mode, setOp);
     }
 
-    private int getColumnIndex(String name, IStructuredResult table)
+    private int getColumnIndex(String name, IStructuredResult table, int colstart)
     {
         Column[] columns = table.getColumns();
-        for (int i = 0; i < columns.length; i++)
+        for (int i = colstart; i < columns.length; i++)
         {
             if (columns[i].getLabel().equals(name)) return i;
         }
@@ -350,7 +377,7 @@
     /**
      * Hold a place for a row when the key is a duplicate.
      */
-    class PlaceHolder
+    static class PlaceHolder
     {
         Object key;
         int pos;
@@ -429,6 +456,7 @@
             {
                 treeRows = null;
             }
+            Map<Object, Integer>lastcache = new HashMap<Object,Integer>();
             for (int j = 0; j < size; j++)
             {
 
@@ -454,6 +482,10 @@
                     map.put(key, rows);
                 }
                 int ii = i;
+                if (lastcache.containsKey(key))
+                {
+                    ii = lastcache.get(key);
+                }
                 while (rows[ii] != null)
                 {
                     /*
@@ -471,10 +503,12 @@
                         // Add a placeholder so that a row goes here
                         map.put(new PlaceHolder(key, rows.length), new Object[0]);
                         // Grow the row array
-                        rows = Arrays.copyOf(rows, rows.length + tables.length);
+                        rows = Arrays.copyOf(rows, rows.length + (rows.length / tables.length / 2 + 1) * tables.length);
                         map.put(key, rows);
                         sortwork += rows.length * rows.length;
                     }
+                    // With many duplicates it can take a long time to find a free slot, so cache the last used
+                    lastcache.put(key, ii);
                 }
                 rows[ii] = row;
                 if (listener.isCanceled())
@@ -547,7 +581,7 @@
         if (mask != null && key != null)
         {
             String keystr = key.toString();
-            String keystr2 = keystr.replaceAll(mask.pattern(), replace == null ? "" : replace); //$NON-NLS-1$
+            String keystr2 = mask.matcher(keystr).replaceAll(replace == null ? "" : replace); //$NON-NLS-1$
             if (!keystr.equals(keystr2))
             {
                 key = keystr2;
@@ -570,7 +604,7 @@
                 }
                 if (sfx != null)
                 {
-                    sfx = sfx.replaceAll(mask.pattern(), replace == null ? "" : replace); //$NON-NLS-1$
+                    sfx = mask.matcher(sfx).replaceAll(replace == null ? "" : replace); //$NON-NLS-1$
                     if (sfx.length() == 0)
                         sfx = null;
                 }
@@ -700,7 +734,7 @@
      * 3 3
      * 4
      * </pre>
-     * 
+     *
      * not
      *
      * <pre>
@@ -856,7 +890,7 @@
         }
     }
 
-    public class ComparedColumn
+    public static class ComparedColumn
     {
         Column description;
         int[] columnIndexes;
@@ -1028,6 +1062,30 @@
         }
     }
 
+    /**
+     * Types of delta retained size.
+     */
+    enum DeltaEncoding {
+        /**
+         * The size delta is exact.
+         */
+        EXACT,
+        /**
+         * The size delta is at least this much.
+         */
+        GE,
+        /**
+         * The size delta is not more than this.
+         */
+        LE,
+        /**
+         * The size delta is uncertain, but this is an
+         * estimate. For example the difference between
+         * two sizes given as greater than or equal to.
+         */
+        APPROX
+    }
+
     public class TableComparisonResult implements IStructuredResult, IIconProvider
     {
         private Column key;
@@ -1086,13 +1144,13 @@
                 case ABSOLUTE:
                     return getAbsoluteValue(cr, comparedColumnIdx, tableIdx);
                 case DIFF_TO_FIRST:
-                    return getDiffToFirst(cr, comparedColumnIdx, tableIdx, false);
+                    return getDiffToPrevious(cr, columnIndex, comparedColumnIdx, tableIdx, 0, false);
                 case DIFF_TO_PREVIOUS:
-                    return getDiffToPrevious(cr, comparedColumnIdx, tableIdx, false);
+                    return getDiffToPrevious(cr, columnIndex, comparedColumnIdx, tableIdx, tableIdx - 1, false);
                 case DIFF_RATIO_TO_FIRST:
-                    return getDiffToFirst(cr, comparedColumnIdx, (tableIdx + 1) / 2, tableIdx % 2 == 0);
+                    return getDiffToPrevious(cr, columnIndex, comparedColumnIdx, (tableIdx + 1) / 2, 0, tableIdx % 2 == 0);
                 case DIFF_RATIO_TO_PREVIOUS:
-                    return getDiffToPrevious(cr, comparedColumnIdx, (tableIdx + 1) / 2, tableIdx % 2 == 0);
+                    return getDiffToPrevious(cr, columnIndex, comparedColumnIdx, (tableIdx + 1) / 2, (tableIdx + 1) / 2 - 1, tableIdx % 2 == 0);
 
                 default:
                     break;
@@ -1769,51 +1827,148 @@
             }
         }
 
-        private Object getDiffToFirst(ComparedRow cr, int comparedColumnIdx, int tableIdx, boolean ratio)
+        /**
+         * Convert a encoded value from a cell.
+         * The value can be encoded, and needs to be
+         * decoded before arithmetic or filtering.
+         * The formatter can handle the encoded
+         * value.
+         * @param value
+         * @param tableIdx
+         * @param comparedColumnIdx
+         * @return the converted value, of the same type
+         * as the original.
+         */
+        private Object valueConvert(Object value, int tableIdx, int comparedColumnIdx)
         {
-            Object tableRow = cr.getRows()[tableIdx];
-            if (tableRow == null) return null;
-
+            // Optimization, presume no converter will change null
+            if (value == null)
+                return null;
             int tableColumnIdx = displayedColumns.get(comparedColumnIdx).getColumnIndexes()[tableIdx];
-            if (tableColumnIdx == -1) return null;
-
-            Object value = tables[tableIdx].getColumnValue(tableRow, tableColumnIdx);
-            Object firstTableValue = getAbsoluteValue(cr, comparedColumnIdx, 0);
-
-            if (value == null && firstTableValue == null) return null;
-
-            if (value == null && (firstTableValue instanceof Number || firstTableValue instanceof Bytes)) return null;
-
-            if ((value instanceof Number || value instanceof Bytes) && firstTableValue == null)
+            if (tableColumnIdx == -1)
+                return value;
+            Filter.ValueConverter vc = (Filter.ValueConverter) tables[tableIdx].getColumns()[tableColumnIdx]
+                            .getData(Filter.ValueConverter.class);
+            if (vc != null)
             {
-                return ratio ? null : value;
-            }
-
-            boolean returnBytes = value instanceof Bytes && firstTableValue instanceof Bytes;
-            if (value instanceof Bytes)
-                value = Long.valueOf(((Bytes)value).getValue());
-
-            if (firstTableValue instanceof Bytes)
-                firstTableValue = Long.valueOf(((Bytes)firstTableValue).getValue());
-
-            if (value instanceof Number && firstTableValue instanceof Number)
-            {
-                Object ret = computeDiff((Number) firstTableValue, (Number) value);
-                if (ratio && ret instanceof Number)
+                if (value instanceof Bytes)
                 {
-                    return percentDivide((Number)ret, (Number)firstTableValue);
+                    double v0 = ((Bytes) value).getValue();
+                    double v = vc.convert(v0);
+                    if (v != v0)
+                        value = new Bytes(Double.valueOf(v).longValue());
                 }
-                else
+                else if (value instanceof Number)
                 {
-                    if (returnBytes)
-                        return new Bytes(((Number)ret).longValue());
-                    return ret;
+                    double v0 = ((Number) value).doubleValue();
+                    double v = vc.convert(v0);
+                    if (v != v0)
+                    {
+                        // Try to convert back to original type
+                        if (value instanceof Long)
+                        {
+                            long v1 = (long)v;
+                            if (v1 == v)
+                                value = v1;
+                            else
+                                value = v;
+                        }
+                        else if (value instanceof Integer)
+                        {
+                            int v1 = (int)v;
+                            if (v1 == v)
+                                value = v1;
+                            else
+                                value = v;
+                        }
+                        else if (value instanceof Short)
+                        {
+                            short v1 = (short)v;
+                            if (v1 == v)
+                                value = v1;
+                            else
+                                value = v;
+                        }
+                        else if (value instanceof Byte)
+                        {
+                            byte v1 = (byte)v;
+                            if (v1 == v)
+                                value = v1;
+                            else
+                                value = v;
+                        }
+                        else if (value instanceof Double)
+                        {
+                            double v1 = (double)v;
+                            if (v1 == v)
+                                value = v1;
+                            else
+                                value = v;
+                        }
+                        else if (value instanceof Float)
+                        {
+                            float v1 = (float)v;
+                            if (v1 == v)
+                                value = v1;
+                            else
+                                value = v;
+                        }
+                        else
+                            value = v;
+                    }
                 }
             }
-            return null;
+            return value;
         }
 
-        private Object getDiffToPrevious(ComparedRow cr, int comparedColumnIdx, int tableIdx, boolean ratio)
+        /**
+         * Did the converted value look like an approximate value?
+         * @param value original value
+         * @param value2 converted value
+         * @param tableIdx the table
+         * @param comparedColumnIdx the column index
+         * @return the approximation type
+         */
+        private DeltaEncoding approxValue(Object value, Object value2, int tableIdx, int comparedColumnIdx)
+        {
+            if (value != null && !value.equals(value2))
+            {
+                int tableColumnIdx = displayedColumns.get(comparedColumnIdx).getColumnIndexes()[tableIdx];
+                if (tableColumnIdx == -1)
+                    return DeltaEncoding.EXACT;
+                try
+                {
+                    String fv = tables[tableIdx].getColumns()[tableColumnIdx].getFormatter().format(value);
+                    if (fv != null)
+                    {
+                        if (fv.startsWith(Messages.RetainedSizeDerivedData_Approximate))
+                            return DeltaEncoding.GE;
+                        else if (fv.startsWith(Messages.CompareTablesQuery_GE))
+                            return DeltaEncoding.GE;
+                        else if (fv.startsWith(Messages.CompareTablesQuery_LE))
+                            return DeltaEncoding.LE;
+                        else if (fv.startsWith(Messages.CompareTablesQuery_APPROX))
+                            return DeltaEncoding.APPROX;
+                    }
+                }
+                catch (IllegalArgumentException e)
+                {}
+            }
+            return DeltaEncoding.EXACT;
+        }
+
+        /**
+         * Get the value for a row and column which is a difference to a previous table
+         * (either the first or the immediately previous table).
+         * @param cr the row of created compared table/tree
+         * @param columnIdx the column index of the created compared table/tree
+         * @param comparedColumnIdx the index for the set of columns of the same name which are compared
+         * @param tableIdx the table to read
+         * @param prevTableIdx the previous table to compare to
+         * @param ratio calculate a ration, not a difference
+         * @return
+         */
+        private Object getDiffToPrevious(ComparedRow cr, int columnIdx, int comparedColumnIdx, int tableIdx, int prevTableIdx, boolean ratio)
         {
             Object tableRow = cr.getRows()[tableIdx];
             if (tableRow == null) return null;
@@ -1822,7 +1977,13 @@
             if (tableColumnIdx == -1) return null;
 
             Object value = tables[tableIdx].getColumnValue(tableRow, tableColumnIdx);
-            Object previousTableValue = getAbsoluteValue(cr, comparedColumnIdx, tableIdx - 1);
+            Object previousTableValue = getAbsoluteValue(cr, comparedColumnIdx, prevTableIdx);
+            Object value2 = valueConvert(value, tableIdx, comparedColumnIdx);
+            DeltaEncoding approxValue = approxValue(value, value2, tableIdx, comparedColumnIdx);
+            value = value2;
+            value2 = valueConvert(previousTableValue, prevTableIdx, comparedColumnIdx);
+            DeltaEncoding approxPreviousValue = approxValue(previousTableValue, value2, prevTableIdx, comparedColumnIdx);
+            previousTableValue = value2;
 
             if (value == null && previousTableValue == null) return null;
 
@@ -1830,7 +1991,20 @@
 
             if ((value instanceof Number || value instanceof Bytes) && previousTableValue == null)
             {
-                return ratio ? null : value;
+                if (ratio)
+                    return null;
+                /*
+                 * Fix up encoding of single value
+                 * The source value has a difference formatter to the output so could need conversion.
+                 */
+                if (approxValue != DeltaEncoding.EXACT)
+                {
+                    if (value instanceof Bytes)
+                        return encodeResult(((Bytes)value).getValue(), true, approxValue, approxPreviousValue, columnIdx);
+                    else
+                        return encodeResult(value, false, approxValue, approxPreviousValue, columnIdx);
+                }
+                return value;
             }
 
             boolean returnBytes = value instanceof Bytes && previousTableValue instanceof Bytes;
@@ -1849,14 +2023,48 @@
                 }
                 else
                 {
-                    if (returnBytes)
-                        return new Bytes(((Number)ret).longValue());
-                    return ret;
+                    return encodeResult(ret, returnBytes, approxValue, approxPreviousValue, columnIdx);
                 }
             }
             return null;
         }
 
+        /**
+         * Encode the result for a delta retained size formatter.
+         * @param ret
+         * @param returnBytes
+         * @param approxValue
+         * @param approxPreviousValue
+         * @param columnIdx
+         * @return
+         */
+        private Object encodeResult(Object ret, boolean returnBytes, DeltaEncoding approxValue, DeltaEncoding approxPreviousValue,
+                        int columnIdx)
+        {
+            if (returnBytes || ret instanceof Long)
+            {
+                long val = ((Number)ret).longValue();
+                Format fmt = columns[columnIdx].getFormatter();
+                if (fmt instanceof DeltaRetainedBytesFormat)
+                {
+                    DeltaRetainedBytesFormat dfmt = (DeltaRetainedBytesFormat)fmt;
+                    if (approxValue == DeltaEncoding.EXACT && approxPreviousValue == DeltaEncoding.EXACT)
+                        ;
+                    else if ((approxValue == DeltaEncoding.GE || approxValue == DeltaEncoding.EXACT) && (approxPreviousValue == DeltaEncoding.EXACT || approxPreviousValue == DeltaEncoding.LE))
+                        val = dfmt.encodege(val);
+                    else if ((approxValue == DeltaEncoding.LE || approxValue == DeltaEncoding.EXACT) && (approxPreviousValue == DeltaEncoding.EXACT || approxPreviousValue == DeltaEncoding.GE))
+                        val = dfmt.encodele(val);
+                    else if (approxValue != DeltaEncoding.EXACT || approxPreviousValue != DeltaEncoding.EXACT)
+                        val = dfmt.encodeun(val);
+                }
+                if (returnBytes)
+                    return new Bytes(val);
+                else
+                    return val;
+            }
+            return ret;
+        }
+
         private Object computeDiff(Number o1, Number o2)
         {
             if (o1 instanceof Long && o2 instanceof Long) return (o2.longValue() - o1.longValue());
@@ -1955,6 +2163,224 @@
             }
         }
 
+        /**
+         * A class to format the difference between two retained sizes.
+         * Similar to {@link org.eclipse.mat.snapshot.query.RetainedSizeDerivedData.RetainedSizeFormat}.
+         * Sorting should use {@link Filter.ValueConverter} so that a dedicated comparator is
+         * not required. See {@link org.eclipse.mat.query.refined.RefinedStructuredResult.NaturalComparator}.
+         */
+        private class DeltaRetainedBytesFormat extends BytesFormat
+        {
+            /**
+             *
+             */
+            private static final long serialVersionUID = 1L;
+            /*
+             * encode >=, <= for +ve -ve byte values
+             * convert long to double for Filter.ValueConverter
+             * > 1,000,000,000,000,000 means >=
+             * <-1,000,000,000,000,000 means <=
+             * <-3,000,000,000,000,000 means ~
+             *
+             * e.g.
+             * ~=   : 39
+             * ~=3  : 33
+             * ~=0  : 30
+             * >=9  : 29
+             * >=3  : 23
+             * >=-3 : 17
+             * >=-10: 10
+             *
+             * <=9  : -11
+             * <=3  : -17
+             * <=-3 : -23
+             * <=-10: -30
+             *
+             * ~-3  : -33
+             * ~-9  : -39
+             */
+            /**
+             * Break point for special encoding.
+             * Chosen to be big, but to fit precisely in a double
+             * as well as a long.
+             */
+            private long SPECIAL = 1000000000000000L;
+            /**
+             * How much to adjust a value to move it into a different range.
+             */
+            private long SPECIAL2 = SPECIAL * 2;
+            /**
+             * Convert the encoded value to a normal value.
+             */
+            final Filter.ValueConverter converter = new Filter.ValueConverter()
+            {
+                public double convert(double source)
+                {
+                    if (source >= SPECIAL + SPECIAL2)
+                        return source - SPECIAL - SPECIAL2; // +ve approx
+                    else if (source >= SPECIAL)
+                        return source - SPECIAL2; // >=
+                    else if (source < -SPECIAL - SPECIAL2)
+                        return source + SPECIAL + SPECIAL2; // -ve approx
+                    else if (source < -SPECIAL)
+                        return source + SPECIAL2; // <=
+                    return source;
+                }
+            };
+
+            /**
+             * Encode a value as greater than or equal.
+             * @param l the raw value
+             * @return the encoded value
+             */
+            private long encodege(long l)
+            {
+                if (l >= SPECIAL)
+                    return SPECIAL - 1 + SPECIAL2; // saturate
+                else if (l < -SPECIAL)
+                    return encodeun(l); // can't be encoded as GE
+                else
+                    return l + SPECIAL2;
+            }
+
+            /**
+             * Encode a value as less than or equal.
+             * @param l the raw value
+             * @return the encoded value
+             */
+            private long encodele(long l)
+            {
+                if (l >= SPECIAL)
+                    return encodeun(l); // can't be coded as LE
+                else if (l < -SPECIAL)
+                    return -SPECIAL - SPECIAL2; // saturate
+                else
+                    return l - SPECIAL2;
+            }
+
+            /**
+             * Encode a value as inexact.
+             * @param l the raw value
+             * @return the encoded value
+             */
+            private long encodeun(long l)
+            {
+                if (l >= 0)
+                    if (l >= Long.MAX_VALUE - SPECIAL - SPECIAL2)
+                        return Long.MAX_VALUE; // saturate
+                    else
+                        return l + SPECIAL2 + SPECIAL;
+                else if (l <= Long.MIN_VALUE + SPECIAL + SPECIAL2)
+                    return Long.MIN_VALUE; // saturate
+                else
+                    return l - SPECIAL2 - SPECIAL;
+            }
+
+            /**
+             * Create a formatter for the difference between two retained sizes.
+             * @param encapsulatedNumberFormat
+             * @param encapsulatedDecimalFormat
+             */
+            public DeltaRetainedBytesFormat(Format encapsulatedNumberFormat, Format encapsulatedDecimalFormat)
+            {
+                super(encapsulatedNumberFormat, encapsulatedDecimalFormat);
+            }
+
+            @Override
+            public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos)
+            {
+                Number v;
+                if (obj instanceof Bytes)
+                    v = ((Bytes)obj).getValue();
+                else
+                    v = (Number) obj;
+
+
+                if (v.longValue() >= SPECIAL)
+                {
+                    if (v.longValue() >= SPECIAL + SPECIAL2)
+                    {
+                        String approx = Messages.CompareTablesQuery_APPROX;
+                        toAppendTo.append(approx);
+                        return super.format(new Bytes(v.longValue() - SPECIAL - SPECIAL2), toAppendTo, pos);
+                    }
+                    else
+                    {
+                        String approx = Messages.CompareTablesQuery_GE;
+                        toAppendTo.append(approx);
+                        return super.format(new Bytes(v.longValue() - SPECIAL2), toAppendTo, pos);
+                    }
+                }
+                else if (v.longValue() < -SPECIAL)
+                {
+                    if (v.longValue() < -SPECIAL - SPECIAL2)
+                    {
+                        String approx = Messages.CompareTablesQuery_APPROX;
+                        toAppendTo.append(approx);
+                        return super.format(new Bytes(v.longValue() + SPECIAL + SPECIAL2), toAppendTo, pos);
+                    }
+                    else
+                    {
+                        String approx = Messages.CompareTablesQuery_LE;
+                        toAppendTo.append(approx);
+                        return super.format(new Bytes(v.longValue() + SPECIAL2), toAppendTo, pos);
+                    }
+                }
+                else
+                {
+                    return super.format(new Bytes(v.longValue()), toAppendTo, pos);
+                }
+            }
+
+            @Override
+            public Object parseObject(String source, ParsePosition pos)
+            {
+                Object ret;
+                for (String match : new String[] {Messages.CompareTablesQuery_GE, Messages.CompareTablesQuery_LE, Messages.CompareTablesQuery_APPROX})
+                {
+                    if (source.regionMatches(pos.getIndex(), match, 0, match.length()))
+                    {
+                        int pi = pos.getIndex();
+                        pos.setIndex(pi + match.length());
+                        ret = super.parseObject(source, pos);
+                        if (ret != null)
+                        {
+                            long v;
+                            if (ret instanceof Bytes)
+                            {
+                                v = ((Bytes)ret).getValue();
+                                if (match == Messages.CompareTablesQuery_GE)
+                                    v = encodege(v);
+                                else if (match == Messages.CompareTablesQuery_LE)
+                                    v = encodele(v);
+                                else if (match == Messages.CompareTablesQuery_APPROX)
+                                    v = encodeun(v);
+                                return new Bytes(v);
+                            }
+                            else if (ret instanceof Number)
+                            {
+                                v = ((Number)ret).longValue();
+                                if (match == Messages.CompareTablesQuery_GE)
+                                    v = encodege(v);
+                                else if (match == Messages.CompareTablesQuery_LE)
+                                    v = encodele(v);
+                                else if (match == Messages.CompareTablesQuery_APPROX)
+                                    v = encodeun(v);
+                                return new Bytes(v);
+                            }
+                        }
+                        // >= in front of something else
+                        pos.setErrorIndex(pi + match.length());
+                        pos.setIndex(pi);
+                        ret = null;
+                        return ret;
+                    }
+                }
+                ret = super.parseObject(source, pos);
+                return ret;
+            }
+        }
+
         private void setFormatter()
         {
             int i = 1;
@@ -1977,6 +2403,7 @@
                 bcf = bcf2;
             }
             BytesFormat bfm = new BytesFormat(formatter, bcf);
+            DeltaRetainedBytesFormat drbfm = new DeltaRetainedBytesFormat(formatter, bcf);
 
             for (ComparedColumn comparedColumn : displayedColumns)
             {
@@ -1994,6 +2421,10 @@
                                             columns[i].getComparator());
                             columns[i].decorator(decorator);
                         }
+                        // Set the converter
+                        Object converter = c.getData(Filter.ValueConverter.class);
+                        if (converter != null || columns[i].getData(Filter.ValueConverter.class) != null)
+                            columns[i].setData(Filter.ValueConverter.class, converter);
                         if (c.getFormatter() instanceof DecimalFormat)
                         {
                             DecimalFormat fm = ((DecimalFormat) c.getFormatter().clone());
@@ -2004,7 +2435,15 @@
                         {
                             //BytesFormat fm = ((BytesFormat) c.getFormatter().clone());
                             // Force the sign - can't retrieve information from existing formatter
-                            columns[i].formatting(bfm);
+                            if (c.getFormatter().getClass() == BytesFormat.class)
+                            {
+                                columns[i].formatting(bfm);
+                            }
+                            else
+                            {
+                                columns[i].formatting(drbfm);
+                                columns[i].setData(Filter.ValueConverter.class, drbfm.converter);
+                            }
                         }
                         else
                         {
@@ -2023,6 +2462,10 @@
                             columns[i].decorator(decorator);
                         }
                         columns[i].formatting(c.getFormatter());
+                        // Set the converter
+                        Object converter = c.getData(Filter.ValueConverter.class);
+                        if (converter != null || columns[i].getData(Filter.ValueConverter.class) != null)
+                            columns[i].setData(Filter.ValueConverter.class, converter);
                     }
                     i++;
                     if ((mode == Mode.DIFF_RATIO_TO_FIRST || mode == Mode.DIFF_RATIO_TO_PREVIOUS) && j > 0)
@@ -2094,18 +2537,43 @@
                     {
                         String label;
                         final int prev = mode == Mode.DIFF_TO_PREVIOUS || mode == Mode.DIFF_RATIO_TO_PREVIOUS ? j - 1 : 0;
+                        Comparator<?>comparator;
                         if (j == 0 || mode == Mode.ABSOLUTE)
                         {
                             label = MessageUtil.format(Messages.CompareTablesQuery_ColumnAbsolute, c.getLabel(), j + 1);
+                            final Comparator<Object> cmp = (Comparator<Object>) c.getComparator();
+                            if (cmp != null)
+                            {
+                                final int tab = j;
+                                comparator = new Comparator<ComparedRow>(){
+                                    public int compare(ComparedRow o1, ComparedRow o2)
+                                    {
+                                        Object row1 = o1.rows[tab];
+                                        Object row2 = o2.rows[tab];
+                                        // Compare nulls - sort first
+                                        if (row1 == null)
+                                            return row2 == null ? 0 : -1;
+                                        else if (row2 == null)
+                                            return 1;
+                                        else
+                                            return cmp.compare(row1, row2);
+                                    }
+                                };
+                            }
+                            else
+                            {
+                                comparator = null;
+                            }
                         }
                         else
                         {
                             label = MessageUtil.format(Messages.CompareTablesQuery_ColumnDifference,
                                             c.getLabel(), j + 1,
                                             prev + 1);
+                            comparator = null;
                         }
                         result.add(new Column(label, c.getType(), c.getAlign(), c.getSortDirection(), c.getFormatter(),
-                                        null));
+                                        comparator));
                         // Pass through the decorator
                         if (c.getDecorator() != null)
                             result.get(result.size() - 1).decorator(new Decorator(c.getDecorator(), j));
@@ -2140,6 +2608,12 @@
             return ret;
         }
 
+        /**
+         * Add the derived operations from the source tables.
+         * No needed as using the RefinedResult versions of the tables
+         * already has them refined.
+         * @param answer
+         */
         void derivedops(ResultMetaData.Builder answer)
         {
             int found = 0;
diff --git a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/MultiplePath2GCRootsQuery.java b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/MultiplePath2GCRootsQuery.java
index b73662b..c370881 100644
--- a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/MultiplePath2GCRootsQuery.java
+++ b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/MultiplePath2GCRootsQuery.java
@@ -208,7 +208,7 @@
 
         public boolean hasChildren(Object element)
         {
-            // to expensive to calculate
+            // too expensive to calculate
             return true;
         }
 
@@ -263,6 +263,39 @@
 
             return result;
         }
+
+        /**
+         * Needed as getElements returns new Nodes each time.
+         */
+        @Override
+        public int hashCode()
+        {
+            final int prime = 31;
+            int result = 1;
+            result = prime * result + level;
+            result = prime * result + objectId;
+            return result;
+        }
+
+        /**
+         * Needed as getElements returns new Nodes each time.
+         */
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (this == obj)
+                return true;
+            if (obj == null)
+                return false;
+            if (getClass() != obj.getClass())
+                return false;
+            Node other = (Node) obj;
+            if (level != other.level)
+                return false;
+            if (objectId != other.objectId)
+                return false;
+            return true;
+        }
     }
 
     private static class ClassNode extends Node
diff --git a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/annotations.properties b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/annotations.properties
index 7bd16b6..24870fc 100644
--- a/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/annotations.properties
+++ b/plugins/org.eclipse.mat.api/src/org/eclipse/mat/internal/snapshot/inspections/annotations.properties
@@ -63,8 +63,10 @@
 merged paths from objects to garbage collection roots grouped by class, so all objects of the same class are shown as one
 
 CompareTablesQuery.name = Compare Tables and Trees
-CompareTablesQuery.menu.0.label = Compare tables and trees with all set operations
-CompareTablesQuery.menu.1.label = Compare tables and trees ignoring addresses when matching keys
+CompareTablesQuery.menu.0.label = 1|Compare tables and trees with all set operations
+CompareTablesQuery.menu.1.label = 2|Compare tables and trees ignoring addresses when matching keys
+CompareTablesQuery.menu.2.label = 3|Compare tables and trees ignoring addresses and array sizes
+CompareTablesQuery.menu.3.label = 4|Compare tables and trees ignoring addresses and array sizes with all set operations
 CompareTablesQuery.help = Compares two or more tables or trees. If the tables or trees are from the same snapshot \
 as the current snapshot then the context menu shows objects from those tables or trees. It also can perform \
 the following operations depending on the setop argument:\n\
@@ -73,6 +75,29 @@
 Table 1\u2296Table 2 The symmetric difference of that row from table 1 and table 2, so all the objects from that row in only one table (or an odd number of tables)\n\
 Table 1\u2216Table 2 The difference of that row between table 1 and table 2, so all the objects from that row in table 1 but not table 2\n\
 Table 2\u2216Table 1 The difference of that row between table 2 and table 1, so all the objects from that row in table 2 but not table 1
+CompareTablesQuery.menu.0.help = Compares two or more tables or trees with set operations. If the tables or trees are from the same snapshot \
+as the current snapshot then the context menu shows objects from those tables or trees. It also performs \
+the following operations via the context menu:\n\
+Table 1\u2229Table 2 The intersection of that row from table 1 and table 2, so only the objects from that row in both tables\n\
+Table 1\u222ATable 2 The intersection of that row from table 1 and table 2, so all the objects from that row in either table\n\
+Table 1\u2296Table 2 The symmetric difference of that row from table 1 and table 2, so all the objects from that row in only one table (or an odd number of tables)\n\
+Table 1\u2216Table 2 The difference of that row between table 1 and table 2, so all the objects from that row in table 1 but not table 2\n\
+Table 2\u2216Table 1 The difference of that row between table 2 and table 1, so all the objects from that row in table 2 but not table 1
+CompareTablesQuery.menu.1.help = Compares two or more tables or trees, matching different objects. Matches keys with different object addresses of the form \
+' @ 0x12345678' and array indices of the form '[1234]' in the prefix so is useful for comparisons of objects between different snapshots.
+CompareTablesQuery.menu.2.help = Compares two or more tables or trees, matching different objects and arrays. Matches keys with different object addresses of the form \
+' @ 0x12345678' and array indices of the form '[1234]' in the prefix so is useful for comparisons of objects between different snapshots. \
+Also matches keys with arrays of different sizes.
+CompareTablesQuery.menu.3.help = Compares two or more tables or trees, matching different objects and arrays and with set operations. Matches keys with different object addresses of the form \
+' @ 0x12345678' and array indices of the form '[1234]' in the prefix so is useful for comparisons of objects between different snapshots \
+or different parts of the same snapshot. \
+Also matches keys with arrays of different sizes, and for tables and trees from the current snapshot performs \
+the following operations via the context menu:\n\
+Table 1\u2229Table 2 The intersection of that row from table 1 and table 2, so only the objects from that row in both tables\n\
+Table 1\u222ATable 2 The intersection of that row from table 1 and table 2, so all the objects from that row in either table\n\
+Table 1\u2296Table 2 The symmetric difference of that row from table 1 and table 2, so all the objects from that row in only one table (or an odd number of tables)\n\
+Table 1\u2216Table 2 The difference of that row between table 1 and table 2, so all the objects from that row in table 1 but not table 2\n\
+Table 2\u2216Table 1 The difference of that row between table 2 and table 1, so all the objects from that row in table 2 but not table 1
 CompareTablesQuery.tables.help = The tables or trees to be compared
 CompareTablesQuery.contents.help = The query contexts corresponding to the tables
 CompareTablesQuery.context.help = The query context of the current snapshot
@@ -86,7 +111,7 @@
 using: \\s@ 0x[0-9a-f]+ or an array index using ^\\[[0-9]+\\]$
 CompareTablesQuery.replace.help = Replacement text for mask matches.
 CompareTablesQuery.prefix.help = Whether to include the prefix of the key column in the match \
-- for example the field name in a path.
+- for example the field name or array index in a path.
 CompareTablesQuery.suffix.help = Whether to include the suffix of the key column in the match \
 - for example the GC root type.
 CompareTablesQuery.extraReferences.help = The key can be extended by adding field references to be \
diff --git a/plugins/org.eclipse.mat.report/src/org/eclipse/mat/query/refined/RefinedStructuredResult.java b/plugins/org.eclipse.mat.report/src/org/eclipse/mat/query/refined/RefinedStructuredResult.java
index 0b234d1..ef6714d 100644
--- a/plugins/org.eclipse.mat.report/src/org/eclipse/mat/query/refined/RefinedStructuredResult.java
+++ b/plugins/org.eclipse.mat.report/src/org/eclipse/mat/query/refined/RefinedStructuredResult.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2008, 2018 SAP AG and IBM Corporation.
+ * Copyright (c) 2008, 2020 SAP AG and IBM Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -20,6 +20,7 @@
 
 import org.eclipse.mat.SnapshotException;
 import org.eclipse.mat.collect.ArrayInt;
+import org.eclipse.mat.query.Bytes;
 import org.eclipse.mat.query.Column;
 import org.eclipse.mat.query.Column.SortDirection;
 import org.eclipse.mat.query.ContextDerivedData;
@@ -107,11 +108,13 @@
     {
         private RefinedStructuredResult refinedResult;
         private int sortColumn;
+        private Filter.ValueConverter converter;
 
         public NaturalComparator(RefinedStructuredResult refinedResult, int sortColumn)
         {
             this.refinedResult = refinedResult;
             this.sortColumn = sortColumn;
+            this.converter = (Filter.ValueConverter)refinedResult.columns.get(sortColumn).getData(Filter.ValueConverter.class);
         }
 
         @SuppressWarnings("unchecked")
@@ -119,6 +122,17 @@
         {
             Object d1 = refinedResult.getColumnValue(o1, sortColumn);
             Object d2 = refinedResult.getColumnValue(o2, sortColumn);
+            if (converter != null)
+            {
+                if (d1 instanceof Bytes)
+                    d1 = converter.convert(((Bytes)d1).getValue());
+                else if (d1 instanceof Number)
+                    d1 = converter.convert(((Number)d1).doubleValue());
+                if (d2 instanceof Bytes)
+                    d2 = converter.convert(((Bytes)d2).getValue());
+                else if (d2 instanceof Number)
+                    d2 = converter.convert(((Number)d2).doubleValue());
+            }
 
             // Compare nulls - sort first
             if (d1 == null)
diff --git a/plugins/org.eclipse.mat.report/src/org/eclipse/mat/query/refined/TotalsCalculator.java b/plugins/org.eclipse.mat.report/src/org/eclipse/mat/query/refined/TotalsCalculator.java
index 0e23684..6df4f0c 100644
--- a/plugins/org.eclipse.mat.report/src/org/eclipse/mat/query/refined/TotalsCalculator.java
+++ b/plugins/org.eclipse.mat.report/src/org/eclipse/mat/query/refined/TotalsCalculator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2008, 2018 SAP AG and IBM Corporation.
+ * Copyright (c) 2008, 2020 SAP AG and IBM Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -68,13 +68,22 @@
 
         double[] sums = new double[thisNumericColumns.size()];
 
+        Filter.ValueConverter converters[] = new Filter.ValueConverter[thisNumericColumns.size()];
+        for (int ii = 0; ii < thisNumericColumns.size(); ii++)
+        {
+            int columnIndex = thisNumericColumns.get(ii);
+            if (columnIndex < 0)
+                continue;
+            converters[ii] = (Filter.ValueConverter)columns.get(columnIndex).getData(Filter.ValueConverter.class);
+        }
+
         int counter = 0;
         ForEachRowLoop: for (Object row : elements)
         {
             // check if canceled
             if (++counter % 100 == 0)
                 if (listener.isCanceled())
-                    throw new IProgressListener.OperationCanceledException();
+                    return answer;
 
             for (int ii = 0; ii < thisNumericColumns.size(); ii++)
             {
@@ -119,6 +128,8 @@
                     }
                 }
 
+                if (converters[ii] != null)
+                    v = converters[ii].convert(v);
                 sums[ii] += v;
             }
         }
diff --git a/plugins/org.eclipse.mat.tests/src/org/eclipse/mat/tests/snapshot/QueryLookupTest.java b/plugins/org.eclipse.mat.tests/src/org/eclipse/mat/tests/snapshot/QueryLookupTest.java
index 3a235b3..8705415 100644
--- a/plugins/org.eclipse.mat.tests/src/org/eclipse/mat/tests/snapshot/QueryLookupTest.java
+++ b/plugins/org.eclipse.mat.tests/src/org/eclipse/mat/tests/snapshot/QueryLookupTest.java
@@ -12,6 +12,8 @@
 package org.eclipse.mat.tests.snapshot;
 
 import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.hamcrest.number.IsCloseTo.closeTo;
 import static org.hamcrest.number.OrderingComparison.greaterThan;
 import static org.hamcrest.number.OrderingComparison.greaterThanOrEqualTo;
 import static org.junit.Assert.assertFalse;
@@ -19,6 +21,10 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
+import java.io.IOException;
+import java.net.URL;
+import java.text.Format;
+import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -27,6 +33,8 @@
 import java.util.Map;
 
 import org.eclipse.mat.SnapshotException;
+import org.eclipse.mat.query.Bytes;
+import org.eclipse.mat.query.Column;
 import org.eclipse.mat.query.ContextProvider;
 import org.eclipse.mat.query.IContextObject;
 import org.eclipse.mat.query.IContextObjectSet;
@@ -36,11 +44,16 @@
 import org.eclipse.mat.query.IStructuredResult;
 import org.eclipse.mat.query.annotations.descriptors.IAnnotatedObjectDescriptor;
 import org.eclipse.mat.query.annotations.descriptors.IArgumentDescriptor;
+import org.eclipse.mat.query.refined.Filter;
+import org.eclipse.mat.query.refined.RefinedResultBuilder;
+import org.eclipse.mat.query.refined.RefinedTable;
+import org.eclipse.mat.query.results.TextResult;
 import org.eclipse.mat.snapshot.IOQLQuery;
 import org.eclipse.mat.snapshot.ISnapshot;
 import org.eclipse.mat.snapshot.OQLParseException;
 import org.eclipse.mat.snapshot.SnapshotFactory;
 import org.eclipse.mat.snapshot.model.IClass;
+import org.eclipse.mat.snapshot.query.RetainedSizeDerivedData;
 import org.eclipse.mat.snapshot.query.SnapshotQuery;
 import org.eclipse.mat.tests.TestSnapshots;
 import org.eclipse.mat.util.VoidProgressListener;
@@ -120,7 +133,6 @@
         assertTrue(r2 != null);
     }
 
-
     /**
      * Test that subtraction comparisons are done, even for sizes.
      */
@@ -374,7 +386,7 @@
             rc = 0;
         for (int i = 0; i < rc; ++i)
         {
-            processRow(snapshot1, r2, i, null, 3, 100, 0.1);
+            processRow(snapshot1, r2, i, null, 3, 50, 0.15);
         }
     }
 
@@ -403,9 +415,9 @@
         }
         for (ContextProvider cp : r2.getResultMetaData().getContextProviders())
         {
-            if (cp.getLabel().equals("Union of Table 1, Table 2 and Table 3") && row.toString().equals("java.lang.invoke.LambdaForm$MH:[1019, 513, 715]"))
-                System.out.println(cp.getLabel());
-            IContextObject context2 = cp.getContext(row); 
+            //if (cp.getLabel().equals("Union of Table 1, Table 2 and Table 3") && row.toString().equals("java.lang.invoke.LambdaForm$MH:[1019, 513, 715]"))
+            //    System.out.println(cp.getLabel());
+            IContextObject context2 = cp.getContext(row);
             if (context2 instanceof IContextObjectSet)
             {
                 IContextObjectSet ic = (IContextObjectSet)context2;
@@ -456,6 +468,295 @@
         }
     }
 
+    @Test
+    public void testCompareDiffRatioPreviousRetained1() throws SnapshotException, ParseException
+    {
+        testCompareDiffRatioPreviousRetained("histogram .*");
+    }
+
+    @Test
+    public void testCompareDiffRatioPreviousRetained2() throws SnapshotException, ParseException
+    {
+        testCompareDiffRatioPreviousRetained("oql \"select toString(c), c.@objectId, c.@objectAddress, c.@objectId.shortValue(), c.@objectId.byteValue(), c.@objectId.floatValue(), c.@objectId.doubleValue() from java.lang.Integer c\"");
+    }
+
+    public void testCompareDiffRatioPreviousRetained(String query) throws SnapshotException, ParseException
+    {
+        boolean verbose = true;
+        String queryId = "comparetablesquery";
+        ISnapshot snapshot1 = TestSnapshots.getSnapshot(TestSnapshots.SUN_JDK6_18_64BIT, false);
+        ISnapshot snapshot2 = TestSnapshots.getSnapshot(TestSnapshots.SUN_JDK6_18_32BIT, false);
+        //ISnapshot snapshot1 = TestSnapshots.getSnapshot(TestSnapshots.OPENJDK_JDK11_04_64BIT, false);
+        //ISnapshot snapshot2 = TestSnapshots.getSnapshot(TestSnapshots.ADOPTOPENJDK_HOTSPOT_JDK11_0_4_11_64BIT, false);
+
+        SnapshotQuery query1 = SnapshotQuery.parse(query, snapshot1);
+        RefinedResultBuilder rb1 = query1.refine(new VoidProgressListener());
+        rb1.setInlineRetainedSizeCalculation(true);
+        rb1.addDefaultContextDerivedColumn(RetainedSizeDerivedData.APPROXIMATE);
+        RefinedTable result1 = (RefinedTable)rb1.build();
+        List<Object>elements1 = new ArrayList<Object>();
+        // Calculate some retained sizes exactly
+        for (int i = 0; i < result1.getRowCount() - 3; i += 4)
+        {
+            elements1.add(result1.getRow(i + 1));
+            elements1.add(result1.getRow(i + 3));
+        }
+        result1.calculate(result1.getJobs().get(0).getContextProvider(), RetainedSizeDerivedData.PRECISE, elements1, null, new VoidProgressListener());
+
+        SnapshotQuery query2 = SnapshotQuery.parse(query, snapshot2);
+        RefinedResultBuilder rb2 = query2.refine(new VoidProgressListener());
+        rb2.setInlineRetainedSizeCalculation(true);
+        rb2.addDefaultContextDerivedColumn(RetainedSizeDerivedData.APPROXIMATE);
+        RefinedTable result2 = (RefinedTable)rb2.build();
+        // Calculate some retained sizes exactly
+        List<Object>elements2 = new ArrayList<Object>();
+        for (int i = 0; i < result2.getRowCount() - 3; i += 4)
+        {
+            elements2.add(result2.getRow(i + 2));
+            elements2.add(result2.getRow(i + 3));
+        }
+        result2.calculate(result2.getJobs().get(0).getContextProvider(), RetainedSizeDerivedData.PRECISE, elements2, null, new VoidProgressListener());
+
+        // Another query without retained sizes
+        SnapshotQuery query3 = SnapshotQuery.parse(query, snapshot1);
+        RefinedResultBuilder rb3 = query3.refine(new VoidProgressListener());
+        //rb3.setInlineRetainedSizeCalculation(true);
+        rb3.addDefaultContextDerivedColumn(RetainedSizeDerivedData.APPROXIMATE);
+        RefinedTable result3 = (RefinedTable)rb3.build();
+        // Calculate some retained sizes exactly
+        List<Object>elements3 = new ArrayList<Object>();
+        for (int i = 0; i < result3.getRowCount() - 3; i += 4)
+        {
+            elements3.add(result3.getRow(i + 1));
+            elements3.add(result3.getRow(i + 2));
+        }
+        result3.calculate(result3.getJobs().get(0).getContextProvider(), RetainedSizeDerivedData.PRECISE, elements3, null, new VoidProgressListener());
+
+        SnapshotQuery queryc = SnapshotQuery.parse(queryId+" -mode DIFF_RATIO_TO_PREVIOUS", snapshot1);
+
+        List<IResultTable> r = new ArrayList<IResultTable>();
+        r.add((IResultTable) result1);
+        r.add((IResultTable) result2);
+        r.add((IResultTable) result3);
+        queryc.setArgument("tables", r);
+        ArrayList<ISnapshot> snapshots = new ArrayList<ISnapshot>();
+        snapshots.add(snapshot1);
+        snapshots.add(snapshot2);
+        snapshots.add(snapshot1);
+        queryc.setArgument("snapshots", snapshots);
+        RefinedResultBuilder rbc = queryc.refine(new VoidProgressListener());
+        rbc.setSortOrder(4, null);
+        IResultTable r2 = (IResultTable)rbc.build();
+        assertTrue(r2 != null);
+        //System.out.println(Arrays.toString(r2.getColumns()));
+        int count1 = 0;
+        int count2 = 0;
+        for (int i = 0; i < r2.getRowCount(); ++i)
+        {
+            Object v0 = r2.getColumnValue(r2.getRow(i), 0);
+            for (int j = 1; j < r2.getColumns().length - 2; j += 5)
+            {
+                /*
+                 * 3 tables, 5 results.
+                 * Table 1
+                 * Table 2 - Table 1
+                 * Table 2 / Table 1
+                 * Table 3 - Table 2
+                 * Table 3 / Table 2
+                 */
+                Object v1 = r2.getColumnValue(r2.getRow(i), j);
+                Object v2 = r2.getColumnValue(r2.getRow(i), j + 1);
+                Object v3 = r2.getColumnValue(r2.getRow(i), j + 2);
+                Object v4 = r2.getColumnValue(r2.getRow(i), j + 3);
+                Object v5 = r2.getColumnValue(r2.getRow(i), j + 4);
+                Column cols[] = r2.getColumns();
+                if (verbose) System.out.println("Row "+i+" "+cols[0].getLabel()+" "+cols[j].getLabel()+" "+cols[j+1].getLabel()+" "+cols[j+2].getLabel()+" "+cols[j+3].getLabel()+" "+cols[j+4].getLabel());
+                if (verbose) System.out.println("Row "+i+" "+v0+" "+v1+" "+v2+" "+v3+" "+v4+" "+v5);
+                // With a difference, if there is a value from table 1 then the difference has a value
+                if (v1 != null)
+                {
+                    if (v2 != null)
+                        ++count1;
+                    if (v3 != null)
+                        ++count2;
+                }
+                /*
+                 * Check formatting and parsing.
+                 */
+                if (v1 != null)
+                {
+                    Format formatter1 = r2.getColumns()[j].getFormatter();
+                    if (formatter1 != null)
+                    {
+                        String fv1 = formatter1.format(v1);
+                        if (verbose) System.out.println(fv1);
+                        assertNotNull(fv1);
+                        Object vo1 = formatter1.parseObject(fv1);
+                        if (v1 instanceof Double)
+                        {
+                            if (vo1 instanceof Long)
+                                assertThat(fv1, ((Long)vo1).doubleValue(), closeTo((Double)v1, 0.01));
+                            else
+                                assertThat(fv1, (Double)vo1, closeTo((Double)v1, 0.01));
+                        }
+                        else if (v1 instanceof Number)
+                        {
+                            // A Bytes formatter can receive long, but return bytes
+                            if (vo1 instanceof Bytes)
+                                assertThat(fv1, ((Bytes)vo1).getValue(), equalTo(((Number)v1).longValue()));
+                            else
+                                assertThat(fv1, ((Number)vo1).doubleValue(), equalTo(((Number)v1).doubleValue()));
+                        }
+                        else
+                            assertThat(fv1, vo1, equalTo(v1));
+                        checkFormat(formatter1,r2.getColumns()[j],j);
+                    }
+                }
+                if (v2 != null)
+                {
+                    Format formatter2 = r2.getColumns()[j + 1].getFormatter();
+                    String fv2 = formatter2.format(v2);
+                    if (verbose) System.out.println(fv2);
+                    assertNotNull(fv2);
+                    Object vo2 = formatter2.parseObject(fv2);
+                    if (v2 instanceof Double)
+                    {
+                        if (vo2 instanceof Long)
+                            assertThat(fv2, ((Long)vo2).doubleValue(), closeTo((Double)v2, 0.01));
+                        else
+                        {
+                            // E.g. percent can be returned as com.ibm.icu.math.BigDecimal
+                            assertThat(fv2, vo2, instanceOf(Double.class));
+                            assertThat(fv2, (Double)vo2, closeTo((Double)v2, 0.01));
+                        }
+                    }
+                    else if (v2 instanceof Number)
+                    {
+                        // A Bytes formatter can receive long, but return bytes
+                        if (vo2 instanceof Bytes)
+                            assertThat(fv2, ((Bytes)vo2).getValue(), equalTo(((Number)v2).longValue()));
+                        else
+                            assertThat(fv2, ((Number)vo2).doubleValue(), equalTo(((Number)v2).doubleValue()));
+                    }
+                    else
+                        assertThat(fv2, vo2, equalTo(v2));
+                    checkFormat(formatter2, r2.getColumns()[j+1],j+1);
+                }
+                if (v3 != null)
+                {
+                    Format formatter3 = r2.getColumns()[j + 2].getFormatter();
+                    String fv3 = formatter3.format(v3);
+                    if (verbose) System.out.println(fv3);
+                    assertNotNull(fv3);
+                    Object vo3 = formatter3.parseObject(fv3);
+                    if (v3 instanceof Double)
+                    {
+                        // E.g. percent can be returned as com.ibm.icu.math.BigDecimal
+                        assertThat(fv3, vo3, instanceOf(Number.class));
+                        // Hamcrest closeTo matcher problem with infinity
+                        if (Double.isInfinite((Double)v3))
+                            assertThat(fv3, vo3, equalTo(v3));
+                        else
+                            assertThat(fv3, ((Number)vo3).doubleValue(), closeTo((Double)v3, 0.01));
+                    }
+                    else
+                        assertThat(fv3, vo3, equalTo(v3));
+                    checkFormat(formatter3, r2.getColumns()[j+2],j+2);
+                }
+                if (v4 != null)
+                {
+                    Format formatter4 = r2.getColumns()[j + 3].getFormatter();
+                    String fv4 = formatter4.format(v4);
+                    if (verbose) System.out.println(fv4);
+                    assertNotNull(fv4);
+                    Object vo4 = formatter4.parseObject(fv4);
+                    if (v4 instanceof Double)
+                    {
+                        if (vo4 instanceof Long)
+                            assertThat(fv4, ((Long)vo4).doubleValue(), closeTo((Double)v4, 0.01));
+                        else
+                        {
+                            // E.g. percent can be returned as com.ibm.icu.math.BigDecimal
+                            assertThat(fv4, vo4, instanceOf(Double.class));
+                            assertThat(fv4, (Double)vo4, closeTo((Double)v4, 0.01));
+                        }
+                    }
+                    else if (v4 instanceof Number)
+                    {
+                        // A Bytes formatter can receive long, but return bytes
+                        if (vo4 instanceof Bytes)
+                            assertThat(fv4, ((Bytes)vo4).getValue(), equalTo(((Number)v4).longValue()));
+                        else
+                            assertThat(fv4, ((Number)vo4).doubleValue(), equalTo(((Number)v4).doubleValue()));
+                    }
+                    else
+                        assertThat(fv4, vo4, equalTo(v4));
+                    checkFormat(formatter4, r2.getColumns()[j+3],j+3);
+                }
+                if (v5 != null)
+                {
+                    Format formatter5 = r2.getColumns()[j + 4].getFormatter();
+                    String fv5 = formatter5.format(v5);
+                    if (verbose) System.out.println(fv5);
+                    assertNotNull(fv5);
+                    Object vo5 = formatter5.parseObject(fv5);
+                    if (v5 instanceof Double)
+                    {
+                        // E.g. percent can be returned as com.ibm.icu.math.BigDecimal
+                        assertThat(fv5, vo5, instanceOf(Number.class));
+                        // Hamcrest closeTo matcher problem with infinity
+                        if (Double.isInfinite((Double)v5))
+                            assertThat(fv5, vo5, equalTo(v5));
+                        else
+                            assertThat(fv5, ((Number)vo5).doubleValue(), closeTo((Double)v5, 0.01));
+                    }
+                    else
+                        assertThat(fv5, vo5, equalTo(v5));
+                    checkFormat(formatter5, r2.getColumns()[j+4],j+4);
+                }
+            }
+        }
+        assertThat(count1, greaterThan(0));
+        assertThat(count2, greaterThan(0));
+    }
+
+    void checkFormat(Format f, Column c, int colIdx) throws ParseException
+    {
+        final long special = 1000000000000000L;
+        long values[]= {Long.MIN_VALUE, -(1L<<53), -(1L<<52), -(1L<<51), -(1L<<50), -special*3, -special*2, -special, 0, special, special * 2, special * 3, 1L>>50, 1L>>51, 1L>>52, 1L>>53, Long.MAX_VALUE};
+        long dl[] = {-special, -special + 1, -1, 0, 1, special - 1, special};
+        Filter.ValueConverter vc = (Filter.ValueConverter)c.getData(Filter.ValueConverter.class);
+        for (long v1 : values)
+        {
+            for (long v2 : dl)
+            {
+                long v = v1 + v2;
+                String s = f.format(v);
+                Object vx = f.parseObject(s);
+                //System.out.println("formatted "+v+" as "+s);
+                if (vx instanceof Bytes)
+                    assertThat(f.toString() + " " + s, ((Bytes)vx).getValue(), equalTo(((Number)v).longValue()));
+                else
+                    assertThat(f.toString() + " " + s, ((Number)vx).longValue(), equalTo(v));
+                if (vc != null)
+                {
+                    // After conversion should be an ordinary number
+                    double d2 = vc.convert(v);
+                    String s2 = f.format(d2);
+                    // but some still might not convert
+                    long limit = 4000000000000000L;
+                    /*
+                     * approximate values outside limit range can't be
+                     * converted to a plain number which can be printed
+                     * without conversion.
+                     */
+                    if (v < limit && v >= -limit || !s.contains("\u2248"))
+                        assertTrue(colIdx+":"+c.getLabel()+" "+f.toString() +" " + vc + "\n" + v + "\n" + d2 + "\n" + s + "\n" + s2, s2.matches("[+-]?[0-9,]+(\\.[0-9]+)?(\\s?%)?"));
+                }
+            }
+        }
+    }
+
     /**
      * Test that set operations intersection is done.
      */
@@ -604,6 +905,7 @@
 
     /**
      * Test that set operations are done.
+     * @throws IOException
      */
     public void testCompareSetOperations(ISnapshot snapshot1, String setOp, int o1[], int o2[], int o3[], int ei1, int e1[], int ei2, int e2[]) throws SnapshotException
     {
@@ -646,6 +948,20 @@
         for (ContextProvider cp : r2.getResultMetaData().getContextProviders())
         {
             //System.out.println(cp+ " " + cp.getLabel());
+            cp.getLabel();
+            URL u = cp.getIcon();
+            if (u != null)
+            {
+                try
+                {
+                    Object o = u.getContent();
+                }
+                catch (IOException e)
+                {
+                    throw new SnapshotException(e);
+                }
+                assertNotNull(u);
+            }
         }
 
         ContextProvider cp1 = r2.getResultMetaData().getContextProviders().get(ei1);
diff --git a/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/compare/CompareBasketView.java b/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/compare/CompareBasketView.java
index ed0a1e4..70a1598 100644
--- a/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/compare/CompareBasketView.java
+++ b/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/compare/CompareBasketView.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010, 2019 SAP AG and IBM Corporation
+ * Copyright (c) 2010, 2020 SAP AG and IBM Corporation
  * All rights reserved. This program and the accompanying materials 
  * are made available under the terms of the Eclipse Public License v1.0 
  * which accompanies this distribution, and is available at 
@@ -36,6 +36,7 @@
 import org.eclipse.mat.query.IResultTable;
 import org.eclipse.mat.query.IResultTree;
 import org.eclipse.mat.query.IStructuredResult;
+import org.eclipse.mat.query.refined.RefinedStructuredResult;
 import org.eclipse.mat.query.registry.ArgumentDescriptor;
 import org.eclipse.mat.query.registry.ArgumentSet;
 import org.eclipse.mat.query.registry.QueryDescriptor;
@@ -162,24 +163,32 @@
 		ComparedResult entry = null;
 		if (pane != null)
 		{
-            QueryResult qr = pane.getAdapter(QueryResult.class);
-            if (qr != null && qr.getSubject() instanceof IResultTree)
-                entry = new ComparedResult(state, editor, (IResultTree)qr.getSubject());
-            if (qr != null && qr.getSubject() instanceof IResultTable)
-                entry = new ComparedResult(state, editor, (IResultTable)qr.getSubject());
+		    RefinedStructuredResult rsr = pane.getAdapter(RefinedStructuredResult.class);
+		    if (rsr != null && rsr instanceof IResultTree)
+		        entry = new ComparedResult(state, editor, (IResultTree)rsr);
+		    else if (rsr != null && rsr instanceof IResultTable)
+		        entry = new ComparedResult(state, editor, (IResultTable)rsr);
+		    else
+		    {
+		        QueryResult qr = pane.getAdapter(QueryResult.class);
+		        if (qr != null && qr.getSubject() instanceof IResultTree)
+		            entry = new ComparedResult(state, editor, (IResultTree)qr.getSubject());
+		        else if (qr != null && qr.getSubject() instanceof IResultTable)
+		            entry = new ComparedResult(state, editor, (IResultTable)qr.getSubject());
+		        else if (pane instanceof HistogramPane)
+		        {
+		            entry = new ComparedResult(state, editor, ((HistogramPane) pane).getHistogram());
+		        }
+		        else if (pane instanceof TableResultPane)
+		        {
+		            entry = new ComparedResult(state, editor, (IResultTable) ((TableResultPane) pane).getSrcQueryResult().getSubject());
+		        }
+		        else if (pane instanceof QueryResultPane)
+		        {
+		            entry = new ComparedResult(state, editor, (IResultTree) ((QueryResultPane) pane).getSrcQueryResult().getSubject());
+		        }
+		    }
 		}
-		if (pane instanceof HistogramPane)
-		{
-			entry = new ComparedResult(state, editor, ((HistogramPane) pane).getHistogram());
-		}
-		else if (pane instanceof TableResultPane)
-		{
-			entry = new ComparedResult(state, editor, (IResultTable) ((TableResultPane) pane).getSrcQueryResult().getSubject());
-		}
-	    else if (pane instanceof QueryResultPane)
-        {
-            entry = new ComparedResult(state, editor, (IResultTree) ((QueryResultPane) pane).getSrcQueryResult().getSubject());
-	    }
 
 		if (entry != null)
 		{
@@ -214,7 +223,7 @@
 	            return true;
 	    }
 		return (pane instanceof HistogramPane) || (pane instanceof TableResultPane) ||
-		                pane instanceof QueryResultPane && 
+		                pane instanceof QueryResultPane &&
 		                ((QueryResultPane) pane).getSrcQueryResult().getSubject() instanceof IResultTree;
 	}
 
@@ -601,7 +610,7 @@
         private final IQueryContext currentContext;
         private final List<ISnapshot> snapshots;
         private final ISnapshot currentSnapshot;
-    
+
         private ComparePolicy(List<IStructuredResult> tables, List<IQueryContext> contexts, IQueryContext currentContext)
         {
             this.tables = tables;
@@ -614,7 +623,7 @@
             }
             currentSnapshot = (ISnapshot)currentContext.get(ISnapshot.class, null);
         }
-    
+
         /**
          * Only operate on queries with multiple tables and query contexts
          */
@@ -632,8 +641,19 @@
                         {
                             if (!argument.getType().isAssignableFrom(res.getClass()))
                             {
-                                // Can't convert table/tree
-                                return false;
+                                if (res instanceof RefinedStructuredResult)
+                                {
+                                    // Perhaps the query needs a specific sort of result, not the refined version
+                                    IStructuredResult isr = ((RefinedStructuredResult)res).unwrap();
+                                    if (!argument.getType().isAssignableFrom(isr.getClass()))
+                                        // Can't convert unwrapped table/tree
+                                        return false;
+                                }
+                                else
+                                {
+                                    // Can't convert table/tree
+                                    return false;
+                                }
                             }
                             foundTables = true;
                         }
@@ -682,19 +702,34 @@
             }
             return foundTables && (foundContexts || foundSnapshots);
         }
-    
+
         public void fillInObjectArguments(ISnapshot snapshot, QueryDescriptor query, ArgumentSet set)
         {
             for (ArgumentDescriptor argument : query.getArguments()) {
+
                 if (IStructuredResult.class.isAssignableFrom(argument.getType()))
                 {
+                    List<IStructuredResult> tables1 = new ArrayList<IStructuredResult>();
+                    // Do we need to unwrap some results?
+                    for (IStructuredResult res : tables)
+                    {
+                        // Perhaps the query needs a specific sort of result, not the refined version
+                        if (!argument.getType().isAssignableFrom(res.getClass()) && res instanceof RefinedStructuredResult)
+                        {
+                            // Already tested in accept() that this works
+                            IStructuredResult isr = ((RefinedStructuredResult)res).unwrap();
+                            tables1.add(isr);
+                        }
+                        else
+                            tables1.add(res);
+                    }
                     if (argument.isMultiple())
                     {
-                        set.setArgumentValue(argument, tables);
+                        set.setArgumentValue(argument, tables1);
                     }
                     else
                     {
-                        set.setArgumentValue(argument, tables.get(0));
+                        set.setArgumentValue(argument, tables1.get(0));
                     }
                 }
                 else if (IQueryContext.class.isAssignableFrom(argument.getType()))
diff --git a/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/internal/panes/QueryResultPane.java b/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/internal/panes/QueryResultPane.java
index 7df9ce3..7303635 100644
--- a/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/internal/panes/QueryResultPane.java
+++ b/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/internal/panes/QueryResultPane.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2008, 2019 SAP AG and IBM Corporation.
+ * Copyright (c) 2008, 2020 SAP AG and IBM Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -34,6 +34,7 @@
 import org.eclipse.mat.query.IResultTree;
 import org.eclipse.mat.query.IStructuredResult;
 import org.eclipse.mat.query.refined.RefinedResultBuilder;
+import org.eclipse.mat.query.refined.RefinedStructuredResult;
 import org.eclipse.mat.query.refined.RefinedTable;
 import org.eclipse.mat.query.refined.RefinedTree;
 import org.eclipse.mat.query.registry.ArgumentSet;
@@ -386,6 +387,10 @@
         {
             return (adapter.cast(srcQueryResult));
         }
+        if (adapter.isAssignableFrom(RefinedStructuredResult.class))
+        {
+            return (adapter.cast(viewer.getResult()));
+        }
         if (adapter.isAssignableFrom(srcQueryResult.getSubject().getClass()))
         {
             return (adapter.cast(srcQueryResult.getSubject()));