SERVER-34373 add aggregation expression to test if type is numeric

Author: George Wangensteen

jstests/aggregation/expressions/is_number.js

@@ -0,0 +1,118 @@
+/*
+ * Tests for the $isNumber aggregation expression.
+ */
+(function() {
+'use strict';
+const coll = db.isNumber_expr;
+coll.drop();
+
+function testIsNumber(inputExprPath, expectedOutput, inputId) {
+    const result = coll.aggregate([
+                           {"$match": {_id: inputId}},
+                           {"$project": {_id: 0, "isNum": {"$isNumber": inputExprPath}}},
+                       ])
+                       .toArray();
+    assert.eq(result, expectedOutput);
+}
+
+// Test when $isNumber evaluates to an integer, when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 1, integerFieldPath: NumberInt(56072)}));
+testIsNumber("$integerFieldPath", [{"isNum": true}], 1);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 11, nestedPath: {nestedNumber: NumberInt(500)}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": true}], 11);
+
+// Test when $isNumber evaluates to a double, when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 2, doubleFieldPath: 56072.2}));
+testIsNumber("$doubleFieldPath", [{"isNum": true}], 2);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 12, nestedPath: {nestedNumber: 56072.2}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": true}], 12);
+
+// Test when $isNumber evaluates to a decimal, when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 3, decimalFieldPath: NumberDecimal("1.234")}));
+testIsNumber("$decimalFieldPath", [{"isNum": true}], 3);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 13, nestedPath: {nestedNumber: NumberDecimal("1.234")}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": true}], 13);
+
+// Test when $isNumber evaluates to a long when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 4, longFieldPath: NumberLong("123456789")}));
+testIsNumber("$longFieldPath", [{"isNum": true}], 4);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 14, nestedPath: {nestedNumber: NumberLong("123456789")}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": true}], 14);
+
+// Test when $isNumber evaluates to null, when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 5, nullFieldPath: null}));
+testIsNumber("$nullFieldPath", [{"isNum": false}], 5);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 15, nestedPath: {nestedNull: null}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": false}], 15);
+
+// Test when $isNumber evaluates to missing, when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 6}));
+testIsNumber("$missingFieldPath", [{"isNum": false}], 6);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 16, nestedPath: {}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": false}], 16);
+
+// Test when $isNumber evaluates to an array, when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 7, arrayFieldPath: [1]}));
+testIsNumber("$arrayFieldPath", [{"isNum": false}], 7);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 17, nestedPath: {nestedArray: [1]}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": false}], 17);
+
+// Test when $isNumber evaluates to a string, when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 8, stringFieldPath: "1234"}));
+testIsNumber("$stringFieldPath", [{"isNum": false}], 8);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 18, nestedPath: {nestedString: "12345"}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": false}], 18);
+
+// Test when $isNumber evaluates to a Date, when the input expression is a document field.
+assert.commandWorked(coll.insert({_id: 9, dateFieldPath: new Date()}));
+testIsNumber("$dateFieldPath", [{"isNum": false}], 9);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 19, nestedPath: {nestedDate: new Date()}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": false}], 19);
+
+// Test when $isNumber evaluates to a BinData, when the input expression is a document field.
+// (UUID's are encoded as binary data)
+assert.commandWorked(coll.insert({_id: 10, binDataFieldPath: UUID()}));
+testIsNumber("$binDataFieldPath", [{"isNum": false}], 10);
+// Same as above, but when the input expression is a nested document field.
+assert.commandWorked(coll.insert({_id: 20, nestedPath: {nestedBinData: UUID()}}));
+testIsNumber("$nestedPath.nestedNumber", [{"isNum": false}], 20);
+
+// Test a few literal expressions, rather than ones retrieved from a document.
+assert.commandWorked(coll.insert({_id: 21}));
+
+// Test when $isNumber's input expression is a literal long.
+testIsNumber(NumberLong("12345678"), [{"isNum": true}], 21);
+
+// Test when $isNumber's input expression is a literal decimal.
+testIsNumber(NumberDecimal("1.2345678"), [{"isNum": true}], 21);
+
+// Test when $isNumber's input expression is a literal int.
+testIsNumber(NumberInt(18), [{"isNum": true}], 21);
+
+// Test when $isNumber's input expression is a literal double.
+testIsNumber(5.34, [{"isNum": true}], 21);
+
+// Test when $isNumber's input expression is null literal.
+testIsNumber(null, [{"isNum": false}], 21);
+
+// Test when $isNumber's input expression is a literal array.
+testIsNumber([[2]], [{"isNum": false}], 21);
+
+// Test when $isNumber's input expression is a literal string.
+testIsNumber("a literal string", [{"isNum": false}], 21);
+
+// Test when $isNumber's input expression is a literal Date.
+testIsNumber(new Date(), [{"isNum": false}], 21);
+
+// Test when $isNumber's input expression is a literal BinData.
+testIsNumber(UUID(), [{"isNum": false}], 21);
+}());

src/mongo/db/pipeline/expression.cpp

@@ -4944,6 +4944,18 @@ const char* ExpressionType::getOpName() const {
     return "$type";
 }
 
+/* ------------------------ ExpressionIsNumber --------------------------- */
+
+Value ExpressionIsNumber::evaluate(const Document& root, Variables* variables) const {
+    Value val(_children[0]->evaluate(root, variables));
+    return Value(val.numeric());
+}
+
+REGISTER_EXPRESSION(isNumber, ExpressionIsNumber::parse);
+const char* ExpressionIsNumber::getOpName() const {
+    return "$isNumber";
+}
+
 /* -------------------------- ExpressionZip ------------------------------ */
 
 REGISTER_EXPRESSION(zip, ExpressionZip::parse);

src/mongo/db/pipeline/expression.h

@@ -2378,6 +2378,18 @@ class ExpressionType final : public ExpressionFixedArity<ExpressionType, 1> {
     }
 };
 
+class ExpressionIsNumber final : public ExpressionFixedArity<ExpressionIsNumber, 1> {
+public:
+    explicit ExpressionIsNumber(const boost::intrusive_ptr<ExpressionContext>& expCtx)
+        : ExpressionFixedArity<ExpressionIsNumber, 1>(expCtx) {}
+
+    Value evaluate(const Document& root, Variables* variables) const final;
+    const char* getOpName() const final;
+
+    void acceptVisitor(ExpressionVisitor* visitor) final {
+        return visitor->visit(this);
+    }
+};
 
 class ExpressionWeek final : public DateExpressionAcceptingTimeZone<ExpressionWeek> {
 public:

src/mongo/db/pipeline/expression_test.cpp

@@ -5520,6 +5520,102 @@ TEST(ExpressionTypeTest, WithMaxKeyValue) {
 
 }  // namespace Type
 
+namespace IsNumber {
+
+TEST(ExpressionIsNumberTest, WithMinKeyValue) {
+    assertExpectedResults("$isNumber", {{{Value(MINKEY)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithDoubleValue) {
+    assertExpectedResults("$isNumber", {{{Value(1.0)}, Value(true)}});
+}
+
+TEST(ExpressionIsNumberTest, WithStringValue) {
+    assertExpectedResults("$isNumber", {{{Value("stringValue"_sd)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithNumericStringValue) {
+    assertExpectedResults("$isNumber", {{{Value("5"_sd)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithObjectValue) {
+    BSONObj objectVal = fromjson("{a: {$literal: 1}}");
+    assertExpectedResults("$isNumber", {{{Value(objectVal)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithArrayValue) {
+    assertExpectedResults("$isNumber", {{{Value(BSON_ARRAY(1 << 2))}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithBinDataValue) {
+    BSONBinData binDataVal = BSONBinData("", 0, BinDataGeneral);
+    assertExpectedResults("$isNumber", {{{Value(binDataVal)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithUndefinedValue) {
+    assertExpectedResults("$isNumber", {{{Value(BSONUndefined)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithOIDValue) {
+    assertExpectedResults("$isNumber", {{{Value(OID())}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithBoolValue) {
+    assertExpectedResults("$isNumber", {{{Value(true)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithDateValue) {
+    Date_t dateVal = BSON("" << DATENOW).firstElement().Date();
+    assertExpectedResults("$isNumber", {{{Value(dateVal)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithNullValue) {
+    assertExpectedResults("$isNumber", {{{Value(BSONNULL)}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithRegexValue) {
+    assertExpectedResults("$isNumber", {{{Value(BSONRegEx("a.b"))}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithSymbolValue) {
+    assertExpectedResults("$isNumber", {{{Value(BSONSymbol("a"))}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithDBRefValue) {
+    assertExpectedResults("$isNumber", {{{Value(BSONDBRef("", OID()))}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithCodeWScopeValue) {
+    assertExpectedResults("$isNumber",
+                          {{{Value(BSONCodeWScope("var x = 3", BSONObj()))}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithCodeValue) {
+    assertExpectedResults("$isNumber", {{{Value(BSONCode("var x = 3"))}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithIntValue) {
+    assertExpectedResults("$isNumber", {{{Value(1)}, Value(true)}});
+}
+
+TEST(ExpressionIsNumberTest, WithDecimalValue) {
+    assertExpectedResults("$isNumber", {{{Value(Decimal128(0.3))}, Value(true)}});
+}
+
+TEST(ExpressionIsNumberTest, WithLongValue) {
+    assertExpectedResults("$isNumber", {{{Value(1LL)}, Value(true)}});
+}
+
+TEST(ExpressionIsNumberTest, WithTimestampValue) {
+    assertExpectedResults("$isNumber", {{{Value(Timestamp(0, 0))}, Value(false)}});
+}
+
+TEST(ExpressionIsNumberTest, WithMaxKeyValue) {
+    assertExpectedResults("$isNumber", {{{Value(MAXKEY)}, Value(false)}});
+}
+
+}  // namespace IsNumber
+
 namespace BuiltinRemoveVariable {
 
 TEST(BuiltinRemoveVariableTest, TypeOfRemoveIsMissing) {

src/mongo/db/pipeline/expression_visitor.h

@@ -71,6 +71,7 @@ class ExpressionIn;
 class ExpressionIndexOfArray;
 class ExpressionIndexOfBytes;
 class ExpressionIndexOfCP;
+class ExpressionIsNumber;
 class ExpressionLet;
 class ExpressionLn;
 class ExpressionLog;
@@ -194,6 +195,7 @@ class ExpressionVisitor {
     virtual void visit(ExpressionIndexOfArray*) = 0;
     virtual void visit(ExpressionIndexOfBytes*) = 0;
     virtual void visit(ExpressionIndexOfCP*) = 0;
+    virtual void visit(ExpressionIsNumber*) = 0;
     virtual void visit(ExpressionLet*) = 0;
     virtual void visit(ExpressionLn*) = 0;
     virtual void visit(ExpressionLog*) = 0;