Fix ExactMatch Filter for Non-Convertible Types; Use RangeFilter on QueryScope Vars

Util/src/main/java/io/deephaven/util/datastructures/CachingSupplier.java

@@ -49,4 +49,14 @@ public OUTPUT_TYPE get() {
         }
         return cachedResult;
     }
+
+    public OUTPUT_TYPE getIfCached() {
+        if (hasCachedResult) { // force a volatile read
+            if (errorResult != null) {
+                throw errorResult;
+            }
+            return cachedResult;
+        }
+        return null;
+    }
 }

engine/table/src/main/java/io/deephaven/engine/table/impl/select/ByteRangeFilter.java

@@ -62,7 +62,7 @@ static WhereFilter makeByteRangeFilter(String columnName, Condition condition, b
             case GREATER_THAN_OR_EQUAL:
                 return geq(columnName, value);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 

engine/table/src/main/java/io/deephaven/engine/table/impl/select/CharRangeFilter.java

@@ -58,7 +58,7 @@ static WhereFilter makeCharRangeFilter(String columnName, Condition condition, c
             case GREATER_THAN_OR_EQUAL:
                 return geq(columnName, value);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 

engine/table/src/main/java/io/deephaven/engine/table/impl/select/DoubleRangeFilter.java

@@ -74,7 +74,7 @@ static WhereFilter makeDoubleRangeFilter(String columnName, Condition condition,
             case GREATER_THAN_OR_EQUAL:
                 return geq(columnName, value);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 

engine/table/src/main/java/io/deephaven/engine/table/impl/select/FloatRangeFilter.java

@@ -70,7 +70,7 @@ static WhereFilter makeFloatRangeFilter(String columnName, Condition condition,
             case GREATER_THAN_OR_EQUAL:
                 return geq(columnName, value);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 

engine/table/src/main/java/io/deephaven/engine/table/impl/select/IntRangeFilter.java

@@ -62,7 +62,7 @@ static WhereFilter makeIntRangeFilter(String columnName, Condition condition, in
             case GREATER_THAN_OR_EQUAL:
                 return geq(columnName, value);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 

engine/table/src/main/java/io/deephaven/engine/table/impl/select/LongRangeFilter.java

@@ -62,7 +62,7 @@ static WhereFilter makeLongRangeFilter(String columnName, Condition condition, l
             case GREATER_THAN_OR_EQUAL:
                 return geq(columnName, value);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 

engine/table/src/main/java/io/deephaven/engine/table/impl/select/RangeFilter.java

@@ -37,9 +37,9 @@
  */
 public class RangeFilter extends WhereFilterImpl {
 
-    private final String columnName;
-    private final Condition condition;
-    private final String value;
+    private String columnName;
+    private String value;
+    private Condition condition;
 
     // The expression prior to being parsed
     private final String expression;
@@ -48,7 +48,7 @@ public class RangeFilter extends WhereFilterImpl {
     private final FormulaParserConfiguration parserConfiguration;
 
     /**
-     * Creates a RangeConditionFilter.
+     * Creates a RangeFilter.
      *
      * @param columnName the column to filter
      * @param condition the condition for filtering
@@ -59,7 +59,7 @@ public RangeFilter(String columnName, Condition condition, String value) {
     }
 
     /**
-     * Creates a RangeConditionFilter.
+     * Creates a RangeFilter.
      *
      * @param columnName the column to filter
      * @param condition the condition for filtering
@@ -73,13 +73,13 @@ public RangeFilter(String columnName, Condition condition, String value, String
     }
 
     /**
-     * Creates a RangeConditionFilter.
+     * Creates a RangeFilter.
      *
      * @param columnName the column to filter
      * @param conditionString the String representation of a condition for filtering
      * @param value a String representation of the numeric filter value
      * @param expression the original expression prior to being parsed
-     * @param parserConfiguration the parser configuration to useyy
+     * @param parserConfiguration the parser configuration to use
      */
     public RangeFilter(String columnName, String conditionString, String value, String expression,
             FormulaParserConfiguration parserConfiguration) {
@@ -89,7 +89,7 @@ public RangeFilter(String columnName, String conditionString, String value, Stri
     // Used for copy method
     private RangeFilter(String columnName, Condition condition, String value, String expression,
             WhereFilter filter, FormulaParserConfiguration parserConfiguration) {
-        Assert.eqTrue(conditionSupported(condition), condition + " is not supported by RangeConditionFilter");
+        Assert.eqTrue(conditionSupported(condition), condition + " is not supported by RangeFilter");
         this.columnName = columnName;
         this.condition = condition;
         this.value = value;
@@ -121,7 +121,7 @@ private static Condition conditionFromString(String conditionString) {
             case ">=":
                 return Condition.GREATER_THAN_OR_EQUAL;
             default:
-                throw new IllegalArgumentException(conditionString + " is not supported by RangeConditionFilter");
+                throw new IllegalArgumentException(conditionString + " is not supported by RangeFilter");
         }
     }
 
@@ -148,50 +148,72 @@ public void init(
             return;
         }
 
-        final ColumnDefinition<?> def = tableDefinition.getColumn(columnName);
+        RuntimeException conversionError = null;
+        ColumnDefinition<?> def = tableDefinition.getColumn(columnName);
         if (def == null) {
-            throw new RuntimeException("Column \"" + columnName + "\" doesn't exist in this table, available columns: "
-                    + tableDefinition.getColumnNames());
+            if ((def = tableDefinition.getColumn(value)) != null) {
+                // fix up for the case where column name and variable name were swapped
+                String tmp = columnName;
+                columnName = value;
+                value = tmp;
+                condition = condition.mirror();
+            } else {
+                conversionError = new RuntimeException("Column \"" + columnName
+                        + "\" doesn't exist in this table, available columns: " + tableDefinition.getColumnNames());
+            }
         }
 
-        final Class<?> colClass = def.getDataType();
+        final Class<?> colClass = def == null ? null : def.getDataType();
+        final MutableObject<Object> realValue = new MutableObject<>();
 
-        final MatchFilter.ColumnTypeConvertor convertor =
-                MatchFilter.ColumnTypeConvertorFactory.getConvertor(def.getDataType());
+        if (def != null) {
+            final MatchFilter.ColumnTypeConvertor convertor =
+                    MatchFilter.ColumnTypeConvertorFactory.getConvertor(def.getDataType());
 
-        RuntimeException conversionError = null;
-        final MutableObject<Object> realValue = new MutableObject<>();
-        try {
-            boolean wasAnArrayType = convertor.convertValue(
-                    def, value, compilationProcessor.getQueryScopeVariables(), realValue::setValue);
-            if (wasAnArrayType) {
-                throw new IllegalArgumentException("RangeConditionFilter does not support array types for column "
-                        + columnName + " with value <" + value + ">");
+            try {
+                boolean wasAnArrayType = convertor.convertValue(
+                        def, value, compilationProcessor.getQueryScopeVariables(), realValue::setValue);
+                if (wasAnArrayType) {
+                    conversionError =
+                            new IllegalArgumentException("RangeFilter does not support array types for column "
+                                    + columnName + " with value <" + value + ">");
+                }
+            } catch (final RuntimeException err) {
+                conversionError = err;
             }
-        } catch (final RuntimeException err) {
-            conversionError = err;
         }
 
         if (conversionError != null) {
             if (expression != null) {
-                filter = ConditionFilter.createConditionFilter(expression, parserConfiguration);
+                try {
+                    filter = ConditionFilter.createConditionFilter(expression, parserConfiguration);
+                } catch (final RuntimeException ignored) {
+                    throw conversionError;
+                }
             } else {
                 throw conversionError;
             }
         } else if (colClass == double.class || colClass == Double.class) {
-            filter = DoubleRangeFilter.makeDoubleRangeFilter(columnName, condition, (double) realValue.getValue());
+            filter = DoubleRangeFilter.makeDoubleRangeFilter(columnName, condition,
+                    TypeUtils.unbox((Double) realValue.getValue()));
         } else if (colClass == float.class || colClass == Float.class) {
-            filter = FloatRangeFilter.makeFloatRangeFilter(columnName, condition, (float) realValue.getValue());
+            filter = FloatRangeFilter.makeFloatRangeFilter(columnName, condition,
+                    TypeUtils.unbox((Float) realValue.getValue()));
         } else if (colClass == char.class || colClass == Character.class) {
-            filter = CharRangeFilter.makeCharRangeFilter(columnName, condition, (char) realValue.getValue());
+            filter = CharRangeFilter.makeCharRangeFilter(columnName, condition,
+                    TypeUtils.unbox((Character) realValue.getValue()));
         } else if (colClass == byte.class || colClass == Byte.class) {
-            filter = ByteRangeFilter.makeByteRangeFilter(columnName, condition, (byte) realValue.getValue());
+            filter = ByteRangeFilter.makeByteRangeFilter(columnName, condition,
+                    TypeUtils.unbox((Byte) realValue.getValue()));
         } else if (colClass == short.class || colClass == Short.class) {
-            filter = ShortRangeFilter.makeShortRangeFilter(columnName, condition, (short) realValue.getValue());
+            filter = ShortRangeFilter.makeShortRangeFilter(columnName, condition,
+                    TypeUtils.unbox((Short) realValue.getValue()));
         } else if (colClass == int.class || colClass == Integer.class) {
-            filter = IntRangeFilter.makeIntRangeFilter(columnName, condition, (int) realValue.getValue());
+            filter = IntRangeFilter.makeIntRangeFilter(columnName, condition,
+                    TypeUtils.unbox((Integer) realValue.getValue()));
         } else if (colClass == long.class || colClass == Long.class) {
-            filter = LongRangeFilter.makeLongRangeFilter(columnName, condition, (long) realValue.getValue());
+            filter = LongRangeFilter.makeLongRangeFilter(columnName, condition,
+                    TypeUtils.unbox((Long) realValue.getValue()));
         } else if (colClass == Instant.class) {
             filter = makeInstantRangeFilter(columnName, condition,
                     DateTimeUtils.epochNanos((Instant) realValue.getValue()));
@@ -216,9 +238,14 @@ public void init(
             // The expression looks like a comparison of number, string, or boolean
             // but the type does not match (or the column type is misconfigured)
             if (expression != null) {
-                filter = ConditionFilter.createConditionFilter(expression, parserConfiguration);
+                try {
+                    filter = ConditionFilter.createConditionFilter(expression, parserConfiguration);
+                } catch (final RuntimeException ignored) {
+                    throw new IllegalArgumentException("RangeFilter does not support type "
+                            + colClass.getSimpleName() + " for column " + columnName);
+                }
             } else {
-                throw new IllegalArgumentException("RangeConditionFilter does not support type "
+                throw new IllegalArgumentException("RangeFilter does not support type "
                         + colClass.getSimpleName() + " for column " + columnName);
             }
         }
@@ -237,7 +264,7 @@ private static LongRangeFilter makeInstantRangeFilter(String columnName, Conditi
             case GREATER_THAN_OR_EQUAL:
                 return new InstantRangeFilter(columnName, value, Long.MAX_VALUE, true, true);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 
@@ -252,7 +279,7 @@ private static LongRangeFilter makeZonedDateTimeRangeFilter(String columnName, C
             case GREATER_THAN_OR_EQUAL:
                 return new ZonedDateTimeRangeFilter(columnName, value, Long.MAX_VALUE, true, true);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 
@@ -268,7 +295,7 @@ private static SingleSidedComparableRangeFilter makeComparableRangeFilter(String
             case GREATER_THAN_OR_EQUAL:
                 return new SingleSidedComparableRangeFilter(columnName, comparable, true, true);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 
@@ -296,6 +323,10 @@ public void setRecomputeListener(RecomputeListener listener) {}
 
     @Override
     public WhereFilter copy() {
+        if (filter != null) {
+            return filter.copy();
+        }
+
         return new RangeFilter(columnName, condition, value, expression, filter, parserConfiguration);
     }
 

engine/table/src/main/java/io/deephaven/engine/table/impl/select/ShortRangeFilter.java

@@ -62,7 +62,7 @@ static WhereFilter makeShortRangeFilter(String columnName, Condition condition,
             case GREATER_THAN_OR_EQUAL:
                 return geq(columnName, value);
             default:
-                throw new IllegalArgumentException("RangeConditionFilter does not support condition " + condition);
+                throw new IllegalArgumentException("RangeFilter does not support condition " + condition);
         }
     }
 

engine/table/src/main/java/io/deephaven/engine/table/impl/select/WhereFilterAdapter.java

@@ -241,8 +241,8 @@ public PreferredLhsColumnRhsVisitor(ColumnName lhs) {
                 this.lhs = Objects.requireNonNull(lhs);
             }
 
-            // The String vs non-String cases are separated out, as it's necessary in the RangeConditionFilter case to
-            // wrap String literals with quotes (as that's what RangeConditionFilter expects wrt parsing). MatchFilter
+            // The String vs non-String cases are separated out, as it's necessary in the RangeFilter case to
+            // wrap String literals with quotes (as that's what RangeFilter expects wrt parsing). MatchFilter
             // allows us to pass in the already parsed Object (otherwise, if we were passing strValues we would need to
             // wrap them)