QL: add unsigned_long type support

x-pack/plugin/eql/src/main/java/org/elasticsearch/xpack/eql/parser/ExpressionBuilder.java

@@ -47,6 +47,7 @@
 import org.elasticsearch.xpack.ql.type.DataTypes;
 import org.elasticsearch.xpack.ql.util.StringUtils;
 
+import java.math.BigInteger;
 import java.time.ZoneId;
 import java.util.List;
 
@@ -207,10 +208,9 @@ public Literal visitIntegerLiteral(EqlBaseParser.IntegerLiteralContext ctx) {
         Source source = source(ctx);
         String text = ctx.getText();
 
-        long value;
-
+        Number value;
         try {
-            value = Long.valueOf(StringUtils.parseLong(text));
+            value = StringUtils.parseInteger(text);
         } catch (QlIllegalArgumentException siae) {
             // if it's too large, then quietly try to parse as a float instead
             try {
@@ -221,15 +221,20 @@ public Literal visitIntegerLiteral(EqlBaseParser.IntegerLiteralContext ctx) {
             throw new ParsingException(source, siae.getMessage());
         }
 
-        Object val = Long.valueOf(value);
-        DataType type = DataTypes.LONG;
-
-        // try to downsize to int if possible (since that's the most common type)
-        if ((int) value == value) {
-            type = DataTypes.INTEGER;
-            val = Integer.valueOf((int) value);
+        DataType type;
+        if (value instanceof BigInteger) {
+            type = DataTypes.UNSIGNED_LONG;
+        } else {
+            assert value instanceof Long : "Expected value [" + value + "] of type Long but got: " + value.getClass();
+            // try to downsize to int if possible (since that's the most common type)
+            if (value.longValue() == value.intValue()) {
+                type = DataTypes.INTEGER;
+                value = Integer.valueOf(value.intValue());
+            } else {
+                type = DataTypes.LONG;
+            }
         }
-        return new Literal(source, val, type);
+        return new Literal(source, value, type);
     }
 
     @Override

x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/analysis/VerifierTests.java

@@ -176,6 +176,7 @@ public void testAliasErrors() {
     // Test all elasticsearch numeric field types
     public void testNumeric() {
         final IndexResolution idxr = loadIndexResolution("mapping-numeric.json");
+        accept(idxr, "foo where unsigned_long_field == 0");
         accept(idxr, "foo where long_field == 0");
         accept(idxr, "foo where integer_field == 0");
         accept(idxr, "foo where short_field == 0");

x-pack/plugin/eql/src/test/resources/mapping-numeric.json

@@ -10,6 +10,9 @@
         "@timestamp" : {
             "type" : "date"
         },
+        "unsigned_long_field" : {
+            "type": "unsigned_long"
+        },
         "long_field" : {
             "type" : "long"
         },

x-pack/plugin/ql/src/main/java/org/elasticsearch/xpack/ql/execution/search/extractor/AbstractFieldHitExtractor.java

@@ -19,6 +19,7 @@
 import org.elasticsearch.xpack.ql.type.DataTypes;
 
 import java.io.IOException;
+import java.math.BigInteger;
 import java.time.ZoneId;
 import java.util.ArrayDeque;
 import java.util.Deque;
@@ -31,6 +32,8 @@
 import static org.elasticsearch.xpack.ql.type.DataTypes.DATETIME;
 import static org.elasticsearch.xpack.ql.type.DataTypes.KEYWORD;
 import static org.elasticsearch.xpack.ql.type.DataTypes.SCALED_FLOAT;
+import static org.elasticsearch.xpack.ql.type.DataTypes.UNSIGNED_LONG;
+
 /**
  * Extractor for ES fields. Works for both 'normal' fields but also nested ones (which require hitName to be set).
  * The latter is used as metadata in assembling the results in the tabular response.
@@ -182,25 +185,16 @@ protected Object unwrapMultiValue(Object values) {
                 return values;
             }
             if (dataType.isNumeric() && isFromDocValuesOnly(dataType) == false) {
-                if (dataType == DataTypes.DOUBLE || dataType == DataTypes.FLOAT || dataType == DataTypes.HALF_FLOAT) {
-                    Number result = null;
-                    try {
-                        result = numberType(dataType).parse(values, true);
-                    } catch(IllegalArgumentException iae) {
-                        return null;
-                    }
-                    // docvalue_fields is always returning a Double value even if the underlying floating point data type is not Double
-                    // even if we don't extract from docvalue_fields anymore, the behavior should be consistent
-                    return result.doubleValue();
-                } else {
-                    Number result = null;
-                    try {
-                        result = numberType(dataType).parse(values, true);
-                    } catch(IllegalArgumentException iae) {
-                        return null;
-                    }
-                    return result;
+                Number result = null;
+                try {
+                    // TODO: don't mapper modules expose _source parsing methods? should the _source be (re)validated?
+                    result = dataType == UNSIGNED_LONG ? new BigInteger(values.toString()) : numberType(dataType).parse(values, true);
+                } catch(IllegalArgumentException iae) {
+                    return null;
                 }
+                // docvalue_fields is always returning a Double value even if the underlying floating point data type is not Double
+                // even if we don't extract from docvalue_fields anymore, the behavior should be consistent
+                return dataType.isRational() ? result.doubleValue() : result;
             } else if (DataTypes.isString(dataType)) {
                 return values.toString();
             } else {
@@ -215,7 +209,7 @@ protected boolean isFromDocValuesOnly(DataType dataType) {
                     || dataType == DATETIME
                     || dataType == SCALED_FLOAT; // because of scaling_factor
     }
-    
+
     private static NumberType numberType(DataType dataType) {
         return NumberType.valueOf(dataType.esType().toUpperCase(Locale.ROOT));
     }
@@ -339,4 +333,4 @@ public boolean equals(Object obj) {
     public int hashCode() {
         return Objects.hash(fieldName, useDocValue, hitName, arrayLeniency);
     }
-}
+}

x-pack/plugin/ql/src/main/java/org/elasticsearch/xpack/ql/expression/predicate/operator/arithmetic/Arithmetics.java

@@ -7,8 +7,11 @@
 
 import org.elasticsearch.xpack.ql.QlIllegalArgumentException;
 
+import java.math.BigInteger;
 import java.util.function.BiFunction;
 
+import static org.elasticsearch.xpack.ql.util.Check.isUnsignedLong;
+
 /**
  * Arithmetic operation using the type widening rules of the JLS 5.6.2 namely
  * widen to double or float or long or int in this order.
@@ -31,6 +34,22 @@ default Object wrap(Object l, Object r) {
         }
     }
 
+    private static BigInteger unsignedLongOperation(Number l, Number r, BiFunction<BigInteger, BigInteger, BigInteger> op) {
+        BigInteger biLeft, biRight;
+        if (l instanceof BigInteger) {
+            biLeft = (BigInteger) l;
+            biRight = BigInteger.valueOf(r.longValue());
+        } else if (r instanceof BigInteger) {
+            biLeft = BigInteger.valueOf(l.longValue());
+            biRight = (BigInteger) r;
+        } else {
+            return null;
+        }
+        BigInteger bi = op.apply(biLeft, biRight);
+        isUnsignedLong(bi);
+        return bi;
+    }
+
     public static Number add(Number l, Number r) {
         if (l == null || r == null) {
             return null;
@@ -42,6 +61,10 @@ public static Number add(Number l, Number r) {
         if (l instanceof Float || r instanceof Float) {
             return Float.valueOf(l.floatValue() + r.floatValue());
         }
+        BigInteger bi = unsignedLongOperation(l, r, BigInteger::add);
+        if (bi != null) {
+            return bi;
+        }
         if (l instanceof Long || r instanceof Long) {
             return Long.valueOf(Math.addExact(l.longValue(), r.longValue()));
         }
@@ -60,6 +83,10 @@ public static Number sub(Number l, Number r) {
         if (l instanceof Float || r instanceof Float) {
             return Float.valueOf(l.floatValue() - r.floatValue());
         }
+        BigInteger bi = unsignedLongOperation(l, r, BigInteger::subtract);
+        if (bi != null) {
+            return bi;
+        }
         if (l instanceof Long || r instanceof Long) {
             return Long.valueOf(Math.subtractExact(l.longValue(), r.longValue()));
         }
@@ -78,6 +105,16 @@ public static Number mul(Number l, Number r) {
         if (l instanceof Float || r instanceof Float) {
             return Float.valueOf(l.floatValue() * r.floatValue());
         }
+        // Note: in case of unsigned_long overflow (or underflow, with negative fixed point numbers), the exception is thrown.
+        // This is unlike the way some other traditional RDBMS that support unsigned types work, which simply promote the result to a
+        // floating point type, but in line with how our implementation treats other fixed point type operations (i.e. Math#xxExact()).
+        // The reason for our behavior is (prolly) the need to establish a schema based on an index mapping. Noteworthy however is also
+        // that we're not strictly consistent with the returned type: a `SUM(field)` aggregation can return a floating point, for example.
+        // TODO: document this last point or address it?
+        BigInteger bi = unsignedLongOperation(l, r, BigInteger::multiply);
+        if (bi != null) {
+            return bi;
+        }
         if (l instanceof Long || r instanceof Long) {
             return Long.valueOf(Math.multiplyExact(l.longValue(), r.longValue()));
         }
@@ -96,6 +133,10 @@ public static Number div(Number l, Number r) {
         if (l instanceof Float || r instanceof Float) {
             return l.floatValue() / r.floatValue();
         }
+        BigInteger bi = unsignedLongOperation(l, r, BigInteger::divide);
+        if (bi != null) {
+            return bi;
+        }
         if (l instanceof Long || r instanceof Long) {
             return l.longValue() / r.longValue();
         }
@@ -114,6 +155,10 @@ public static Number mod(Number l, Number r) {
         if (l instanceof Float || r instanceof Float) {
             return Float.valueOf(l.floatValue() % r.floatValue());
         }
+        BigInteger bi = unsignedLongOperation(l, r, BigInteger::remainder);
+        if (bi != null) {
+            return bi;
+        }
         if (l instanceof Long || r instanceof Long) {
             return Long.valueOf(l.longValue() % r.longValue());
         }
@@ -140,10 +185,16 @@ static Number negate(Number n) {
             }
             return Float.valueOf(-n.floatValue());
         }
+        if (n instanceof BigInteger) {
+            if (((BigInteger) n).signum() != 0) {
+                throw new ArithmeticException("unsigned_long overflow");
+            }
+            return n;
+        }
         if (n instanceof Long) {
             return Long.valueOf(Math.negateExact(n.longValue()));
         }
 
         return Integer.valueOf(Math.negateExact(n.intValue()));
     }
-}
+}