SERVER-99739: Round floating points in QueryTester results to 15 digits (#31473)

GitOrigin-RevId: 4e629e2476c5c1952f8cac7a75a3b03f2821686f

Author: wqian94

src/mongo/db/query/query_tester/test.cpp

@@ -164,11 +164,13 @@ NormalizationOptsSet Test::parseResultType(const std::string& type) {
              NormalizationOpts::kSortArrays | NormalizationOpts::kNormalizeNumerics},
         {":sortFull",
          NormalizationOpts::kSortResults | NormalizationOpts::kSortBSON |
-             NormalizationOpts::kSortArrays},
+             NormalizationOpts::kSortArrays | NormalizationOpts::kRoundFloatingPointNumerics},
         {":sortBSONNormalizeNumerics",
          NormalizationOpts::kSortResults | NormalizationOpts::kSortBSON |
              NormalizationOpts::kNormalizeNumerics},
-        {":sortBSON", NormalizationOpts::kSortResults | NormalizationOpts::kSortBSON},
+        {":sortBSON",
+         NormalizationOpts::kSortResults | NormalizationOpts::kSortBSON |
+             NormalizationOpts::kRoundFloatingPointNumerics},
         {":sortResultsNormalizeNumerics",
          NormalizationOpts::kSortResults | NormalizationOpts::kNormalizeNumerics},
         {":normalizeNumerics", NormalizationOpts::kNormalizeNumerics},

src/mongo/shell/shell_utils.cpp

@@ -919,6 +919,54 @@ BSONObj normalizeNumerics(const BSONObj& input) {
     return bob.obj();
 }
 
+void roundFloatingPointNumericElementsHelper(const BSONObj& input, BSONObjBuilder& bob);
+
+void roundFloatingPointNumericElements(const BSONElement& el, BSONObjBuilder& bob) {
+    switch (el.type()) {
+        case NumberDouble: {
+            // Take advantage of Decimal128's ability to round to 15 digits at construction time.
+            bob.append(el.fieldName(),
+                       Decimal128(el.numberDouble(), Decimal128::kRoundTo15Digits).toDouble());
+            break;
+        }
+        case Array: {
+            BSONObjBuilder sub(bob.subarrayStart(el.fieldNameStringData()));
+            for (const auto& child : el.Array()) {
+                roundFloatingPointNumericElements(child, sub);
+            }
+            sub.doneFast();
+            break;
+        }
+        case Object: {
+            BSONObjBuilder sub(bob.subobjStart(el.fieldNameStringData()));
+            roundFloatingPointNumericElementsHelper(el.Obj(), sub);
+            sub.doneFast();
+            break;
+        }
+        default:
+            bob.append(el);
+            break;
+    }
+}
+
+void roundFloatingPointNumericElementsHelper(const BSONObj& input, BSONObjBuilder& bob) {
+    BSONObjIterator it(input);
+    while (it.more()) {
+        roundFloatingPointNumericElements(it.next(), bob);
+    }
+}
+
+/**
+ * Returns a new BSONObj with the same field/value pairings, but with floating-point types rounded
+ * to 15 digits of precision. For example, 1.000000000000001 and NumberDecimal('1') would
+ * be normalized into the same number.
+ */
+BSONObj roundFloatingPointNumerics(const BSONObj& input) {
+    BSONObjBuilder bob(input.objsize());
+    roundFloatingPointNumericElementsHelper(input, bob);
+    return bob.obj();
+}
+
 void removeNullAndUndefinedElementsHelper(const BSONObj& input, BSONObjBuilder& bob);
 
 template <typename Builder>
@@ -986,6 +1034,9 @@ BSONObj normalizeBSONObj(const BSONObj& input, NormalizationOptsSet opts) {
     if (isSet(opts, NormalizationOpts::kConflateNullAndMissing)) {
         result = removeNullAndUndefined(result);
     }
+    if (isSet(opts, NormalizationOpts::kRoundFloatingPointNumerics)) {
+        result = roundFloatingPointNumerics(result);
+    }
     if (isSet(opts, NormalizationOpts::kNormalizeNumerics)) {
         result = normalizeNumerics(result);
     }

src/mongo/shell/shell_utils.h

@@ -125,6 +125,8 @@ enum class NormalizationOpts : uint32_t {
     kNormalizeNumerics = 1 << 3,
     // Set this bit to treat null and missing as the same value.
     kConflateNullAndMissing = 1 << 4,
+    // Set this bit to round floating points to 15 digits of precision.
+    kRoundFloatingPointNumerics = 1 << 5,
 };
 using NormalizationOptsSet = NormalizationOpts;
 

src/mongo/shell/shell_utils_test.cpp

@@ -402,5 +402,14 @@ TEST(NormalizationOpts, NormalizeFullConflateNullAndMissing) {
         "c: 1.000000000000000000000000000000000 } }";
     ASSERT_EQ(normalizeBSONObj(bson, opts).toString(), expected);
 }
+
+TEST(NormalizationOpts, RoundedFloatingPointNumericsAreEqual) {
+    auto bson = fromjson("{a: {z: 1.234567890123456789, y: [9.876543210987654321, 1]}}");
+    auto opts = NormalizationOpts::kRoundFloatingPointNumerics | NormalizationOpts::kSortBSON |
+        NormalizationOpts::kSortArrays;
+
+    auto expected = "{ a: { y: [ 1, 9.87654321098765 ], z: 1.23456789012346 } }";
+    ASSERT_EQ(normalizeBSONObj(bson, opts).toString(), expected);
+}
 }  // namespace
 }  // namespace mongo