libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-range-mincover.c

@@ -80,7 +80,7 @@ void mc_mincover_destroy(mc_mincover_t *mincover) {
 
 // The 128-bit version is only required for Decimal128, otherwise generates
 // unused-fn warnings
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 #define UINT_T mlib_int128
 #define UINT_C MLIB_INT128
 #define UINT_FMT_S "s"
@@ -133,7 +133,7 @@ void mc_mincover_destroy(mc_mincover_t *mincover) {
     } else                                                                                                             \
         (void)0
 
-mc_mincover_t *mc_getMincoverInt32(mc_getMincoverInt32_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+mc_mincover_t *mc_getMincoverInt32(mc_getMincoverInt32_args_t args, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(status);
     CHECK_BOUNDS(args, PRId32, IDENTITY, LESSTHAN);
     mc_OSTType_Int32 a, b;
@@ -156,7 +156,7 @@ mc_mincover_t *mc_getMincoverInt32(mc_getMincoverInt32_args_t args, mongocrypt_s
     }
 
     MinCoverGenerator_u32 *mcg =
-        MinCoverGenerator_new_u32(a.value, b.value, a.max, args.sparsity, args.trimFactor, status, use_range_v2);
+        MinCoverGenerator_new_u32(a.value, b.value, a.max, args.sparsity, args.trimFactor, status);
     if (!mcg) {
         return NULL;
     }
@@ -166,7 +166,7 @@ mc_mincover_t *mc_getMincoverInt32(mc_getMincoverInt32_args_t args, mongocrypt_s
     return mc;
 }
 
-mc_mincover_t *mc_getMincoverInt64(mc_getMincoverInt64_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+mc_mincover_t *mc_getMincoverInt64(mc_getMincoverInt64_args_t args, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(status);
     CHECK_BOUNDS(args, PRId64, IDENTITY, LESSTHAN);
     mc_OSTType_Int64 a, b;
@@ -189,7 +189,7 @@ mc_mincover_t *mc_getMincoverInt64(mc_getMincoverInt64_args_t args, mongocrypt_s
     }
 
     MinCoverGenerator_u64 *mcg =
-        MinCoverGenerator_new_u64(a.value, b.value, a.max, args.sparsity, args.trimFactor, status, use_range_v2);
+        MinCoverGenerator_new_u64(a.value, b.value, a.max, args.sparsity, args.trimFactor, status);
     if (!mcg) {
         return NULL;
     }
@@ -201,7 +201,7 @@ mc_mincover_t *mc_getMincoverInt64(mc_getMincoverInt64_args_t args, mongocrypt_s
 
 // mc_getMincoverDouble implements the Mincover Generation algorithm described
 // in SERVER-68600 for double.
-mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(status);
     CHECK_BOUNDS(args, "g", IDENTITY, LESSTHAN);
 
@@ -211,8 +211,7 @@ mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args, mongocrypt
                                                             .max = args.max,
                                                             .precision = args.precision},
                               &a,
-                              status,
-                              use_range_v2)) {
+                              status)) {
         return NULL;
     }
     if (!mc_getTypeInfoDouble((mc_getTypeInfoDouble_args_t){.value = args.upperBound,
@@ -220,8 +219,7 @@ mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args, mongocrypt
                                                             .max = args.max,
                                                             .precision = args.precision},
                               &b,
-                              status,
-                              use_range_v2)) {
+                              status)) {
         return NULL;
     }
 
@@ -233,7 +231,7 @@ mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args, mongocrypt
     }
 
     MinCoverGenerator_u64 *mcg =
-        MinCoverGenerator_new_u64(a.value, b.value, a.max, args.sparsity, args.trimFactor, status, use_range_v2);
+        MinCoverGenerator_new_u64(a.value, b.value, a.max, args.sparsity, args.trimFactor, status);
     if (!mcg) {
         return NULL;
     }
@@ -243,9 +241,8 @@ mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args, mongocrypt
     return mc;
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
-mc_mincover_t *
-mc_getMincoverDecimal128(mc_getMincoverDecimal128_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
+mc_mincover_t *mc_getMincoverDecimal128(mc_getMincoverDecimal128_args_t args, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(status);
 #define ToString(Dec) (mc_dec128_to_string(Dec).str)
     CHECK_BOUNDS(args, "s", ToString, mc_dec128_less);
@@ -256,8 +253,7 @@ mc_getMincoverDecimal128(mc_getMincoverDecimal128_args_t args, mongocrypt_status
                                                                     .max = args.max,
                                                                     .precision = args.precision},
                                   &a,
-                                  status,
-                                  use_range_v2)) {
+                                  status)) {
         return NULL;
     }
     if (!mc_getTypeInfoDecimal128((mc_getTypeInfoDecimal128_args_t){.value = args.upperBound,
@@ -265,8 +261,7 @@ mc_getMincoverDecimal128(mc_getMincoverDecimal128_args_t args, mongocrypt_status
                                                                     .max = args.max,
                                                                     .precision = args.precision},
                                   &b,
-                                  status,
-                                  use_range_v2)) {
+                                  status)) {
         return NULL;
     }
 
@@ -278,7 +273,7 @@ mc_getMincoverDecimal128(mc_getMincoverDecimal128_args_t args, mongocrypt_status
     }
 
     MinCoverGenerator_u128 *mcg =
-        MinCoverGenerator_new_u128(a.value, b.value, a.max, args.sparsity, args.trimFactor, status, use_range_v2);
+        MinCoverGenerator_new_u128(a.value, b.value, a.max, args.sparsity, args.trimFactor, status);
     if (!mcg) {
         return NULL;
     }

data/ext/libmongocrypt/libmongocrypt/src/mc-rangeopts-private.h

@@ -55,7 +55,7 @@ BSON_STATIC_ASSERT2(alignof_mc_RangeOpts_t,
  *    "trimFactor": Optional<Int32>,
  * }
  */
-bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2, mongocrypt_status_t *status);
+bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, mongocrypt_status_t *status);
 
 /*
  * mc_RangeOpts_to_FLE2RangeInsertSpec creates a placeholder value to be
@@ -76,7 +76,6 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
 bool mc_RangeOpts_to_FLE2RangeInsertSpec(const mc_RangeOpts_t *ro,
                                          const bson_t *v,
                                          bson_t *out,
-                                         bool use_range_v2,
                                          mongocrypt_status_t *status);
 
 /* mc_RangeOpts_appendMin appends the minimum value of the range for a given
@@ -104,8 +103,7 @@ bool mc_RangeOpts_appendTrimFactor(const mc_RangeOpts_t *ro,
                                    bson_type_t valueType,
                                    const char *fieldName,
                                    bson_t *out,
-                                   mongocrypt_status_t *status,
-                                   bool use_range_v2);
+                                   mongocrypt_status_t *status);
 
 void mc_RangeOpts_cleanup(mc_RangeOpts_t *ro);
 

data/ext/libmongocrypt/libmongocrypt/src/mc-rangeopts.c

@@ -25,31 +25,24 @@
 
 #include <float.h> // DBL_MAX
 
-#define CLIENT_ERR_PREFIXED_HELPER(Prefix, ErrorString, ...) CLIENT_ERR(Prefix ": " ErrorString, ##__VA_ARGS__)
-#define CLIENT_ERR_PREFIXED(ErrorString, ...) CLIENT_ERR_PREFIXED_HELPER(ERROR_PREFIX, ErrorString, ##__VA_ARGS__)
-
 // Common logic for testing field name, tracking duplication, and presence.
 #define IF_FIELD(Name)                                                                                                 \
     if (0 == strcmp(field, #Name)) {                                                                                   \
         if (has_##Name) {                                                                                              \
-            CLIENT_ERR_PREFIXED("Unexpected duplicate field '" #Name "'");                                             \
+            CLIENT_ERR(ERROR_PREFIX "Unexpected duplicate field '" #Name "'");                                         \
             return false;                                                                                              \
         }                                                                                                              \
-        has_##Name = true;
+        has_##Name = true;                                                                                             \
+    ((void)0)
 
 #define END_IF_FIELD                                                                                                   \
     continue;                                                                                                          \
-    }
-
-#define CHECK_HAS(Name)                                                                                                \
-    if (!has_##Name) {                                                                                                 \
-        CLIENT_ERR_PREFIXED("Missing field '" #Name "'");                                                              \
-        return false;                                                                                                  \
-    }
+    }                                                                                                                  \
+    else((void)0)
 
-#define ERROR_PREFIX "Error parsing RangeOpts"
+#define ERROR_PREFIX "Error parsing RangeOpts: "
 
-bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2, mongocrypt_status_t *status) {
+bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, mongocrypt_status_t *status) {
     bson_iter_t iter = {0};
     bool has_min = false, has_max = false, has_sparsity = false, has_precision = false, has_trimFactor = false;
     BSON_ASSERT_PARAM(ro);
@@ -60,7 +53,7 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
     ro->bson = bson_copy(in);
 
     if (!bson_iter_init(&iter, ro->bson)) {
-        CLIENT_ERR_PREFIXED("Invalid BSON");
+        CLIENT_ERR(ERROR_PREFIX "Invalid BSON");
         return false;
     }
 
@@ -68,54 +61,63 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
         const char *field = bson_iter_key(&iter);
         BSON_ASSERT(field);
 
-        IF_FIELD(min)
-        ro->min.set = true;
-        ro->min.value = iter;
-        END_IF_FIELD
+        IF_FIELD(min);
+        {
+            ro->min.set = true;
+            ro->min.value = iter;
+        }
+        END_IF_FIELD;
 
-        IF_FIELD(max)
-        ro->max.set = true;
-        ro->max.value = iter;
-        END_IF_FIELD
+        IF_FIELD(max);
+        {
+            ro->max.set = true;
+            ro->max.value = iter;
+        }
+        END_IF_FIELD;
 
-        IF_FIELD(sparsity)
-        if (!BSON_ITER_HOLDS_INT64(&iter)) {
-            CLIENT_ERR_PREFIXED("Expected int64 for sparsity, got: %s", mc_bson_type_to_string(bson_iter_type(&iter)));
-            return false;
-        };
-        ro->sparsity = bson_iter_int64(&iter);
-        END_IF_FIELD
+        IF_FIELD(sparsity);
+        {
+            if (!BSON_ITER_HOLDS_INT64(&iter)) {
+                CLIENT_ERR(ERROR_PREFIX "Expected int64 for sparsity, got: %s",
+                           mc_bson_type_to_string(bson_iter_type(&iter)));
+                return false;
+            }
+            ro->sparsity = bson_iter_int64(&iter);
+        }
+        END_IF_FIELD;
 
-        IF_FIELD(precision) {
+        IF_FIELD(precision);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("'precision' must be an int32");
+                CLIENT_ERR(ERROR_PREFIX "'precision' must be an int32");
                 return false;
             }
             int32_t val = bson_iter_int32(&iter);
             if (val < 0) {
-                CLIENT_ERR_PREFIXED("'precision' must be non-negative");
+                CLIENT_ERR(ERROR_PREFIX "'precision' must be non-negative");
                 return false;
             }
             ro->precision = OPT_I32(val);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        IF_FIELD(trimFactor) {
+        IF_FIELD(trimFactor);
+        {
             if (!BSON_ITER_HOLDS_INT32(&iter)) {
-                CLIENT_ERR_PREFIXED("Expected int32 for trimFactor, got: %s",
-                                    mc_bson_type_to_string(bson_iter_type(&iter)));
+                CLIENT_ERR(ERROR_PREFIX "Expected int32 for trimFactor, got: %s",
+                           mc_bson_type_to_string(bson_iter_type(&iter)));
                 return false;
-            };
+            }
             int32_t val = bson_iter_int32(&iter);
             if (val < 0) {
-                CLIENT_ERR_PREFIXED("'trimFactor' must be non-negative");
+                CLIENT_ERR(ERROR_PREFIX "'trimFactor' must be non-negative");
                 return false;
             }
             ro->trimFactor = OPT_I32(val);
         }
-        END_IF_FIELD
+        END_IF_FIELD;
 
-        CLIENT_ERR_PREFIXED("Unrecognized field: '%s'", field);
+        CLIENT_ERR(ERROR_PREFIX "Unrecognized field: '%s'", field);
         return false;
     }
 
@@ -124,35 +126,35 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
     // applies to double/decimal128.
     // Do not error if trimFactor is not present. It is optional.
 
-    if (!has_sparsity && use_range_v2) {
+    if (!has_sparsity) {
         ro->sparsity = mc_FLERangeSparsityDefault;
     }
 
     // Expect precision only to be set for double or decimal128.
     if (has_precision) {
         if (!ro->min.set) {
-            CLIENT_ERR_PREFIXED("setting precision requires min");
+            CLIENT_ERR(ERROR_PREFIX "setting precision requires min");
             return false;
         }
 
         bson_type_t minType = bson_iter_type(&ro->min.value);
         if (minType != BSON_TYPE_DOUBLE && minType != BSON_TYPE_DECIMAL128) {
-            CLIENT_ERR_PREFIXED("expected 'precision' to be set with double or decimal128 "
-                                "index, but got: %s min",
-                                mc_bson_type_to_string(minType));
+            CLIENT_ERR(ERROR_PREFIX "expected 'precision' to be set with double or decimal128 "
+                                    "index, but got: %s min",
+                       mc_bson_type_to_string(minType));
             return false;
         }
 
         if (!ro->max.set) {
-            CLIENT_ERR_PREFIXED("setting precision requires max");
+            CLIENT_ERR(ERROR_PREFIX "setting precision requires max");
             return false;
         }
 
         bson_type_t maxType = bson_iter_type(&ro->max.value);
         if (maxType != BSON_TYPE_DOUBLE && maxType != BSON_TYPE_DECIMAL128) {
-            CLIENT_ERR_PREFIXED("expected 'precision' to be set with double or decimal128 "
-                                "index, but got: %s max",
-                                mc_bson_type_to_string(maxType));
+            CLIENT_ERR(ERROR_PREFIX "expected 'precision' to be set with double or decimal128 "
+                                    "index, but got: %s max",
+                       mc_bson_type_to_string(maxType));
             return false;
         }
     }
@@ -161,10 +163,10 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
     if (ro->min.set && ro->max.set) {
         bson_type_t minType = bson_iter_type(&ro->min.value), maxType = bson_iter_type(&ro->max.value);
         if (minType != maxType) {
-            CLIENT_ERR_PREFIXED("expected 'min' and 'max' to be same type, but got: %s "
-                                "min and %s max",
-                                mc_bson_type_to_string(minType),
-                                mc_bson_type_to_string(maxType));
+            CLIENT_ERR(ERROR_PREFIX "expected 'min' and 'max' to be same type, but got: %s "
+                                    "min and %s max",
+                       mc_bson_type_to_string(minType),
+                       mc_bson_type_to_string(maxType));
             return false;
         }
     }
@@ -175,8 +177,8 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
             bson_type_t minType = bson_iter_type(&ro->min.value);
             if (minType == BSON_TYPE_DOUBLE || minType == BSON_TYPE_DECIMAL128) {
                 if (!has_precision) {
-                    CLIENT_ERR_PREFIXED("expected 'precision' to be set with 'min' for %s",
-                                        mc_bson_type_to_string(minType));
+                    CLIENT_ERR(ERROR_PREFIX "expected 'precision' to be set with 'min' for %s",
+                               mc_bson_type_to_string(minType));
                     return false;
                 }
             }
@@ -186,8 +188,8 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
             bson_type_t maxType = bson_iter_type(&ro->max.value);
             if (maxType == BSON_TYPE_DOUBLE || maxType == BSON_TYPE_DECIMAL128) {
                 if (!has_precision) {
-                    CLIENT_ERR_PREFIXED("expected 'precision' to be set with 'max' for %s",
-                                        mc_bson_type_to_string(maxType));
+                    CLIENT_ERR(ERROR_PREFIX "expected 'precision' to be set with 'max' for %s",
+                               mc_bson_type_to_string(maxType));
                     return false;
                 }
             }
@@ -195,11 +197,6 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
     }
 
     if (ro->trimFactor.set) {
-        if (!use_range_v2) {
-            // Once `use_range_v2` is default true, this block may be removed.
-            CLIENT_ERR_PREFIXED("'trimFactor' is not supported for QE range v1");
-            return false;
-        }
         // At this point, we do not know the type of the field if min and max are unspecified. Wait to
         // validate the value of trimFactor.
     }
@@ -208,12 +205,11 @@ bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2,
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error making FLE2RangeInsertSpec"
+#define ERROR_PREFIX "Error making FLE2RangeInsertSpec: "
 
 bool mc_RangeOpts_to_FLE2RangeInsertSpec(const mc_RangeOpts_t *ro,
                                          const bson_t *v,
                                          bson_t *out,
-                                         bool use_range_v2,
                                          mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(ro);
     BSON_ASSERT_PARAM(v);
@@ -222,17 +218,17 @@ bool mc_RangeOpts_to_FLE2RangeInsertSpec(const mc_RangeOpts_t *ro,
 
     bson_iter_t v_iter;
     if (!bson_iter_init_find(&v_iter, v, "v")) {
-        CLIENT_ERR_PREFIXED("Unable to find 'v' in input");
+        CLIENT_ERR(ERROR_PREFIX "Unable to find 'v' in input");
         return false;
     }
 
     bson_t child;
     if (!BSON_APPEND_DOCUMENT_BEGIN(out, "v", &child)) {
-        CLIENT_ERR_PREFIXED("Error appending to BSON");
+        CLIENT_ERR(ERROR_PREFIX "Error appending to BSON");
         return false;
     }
     if (!bson_append_iter(&child, "v", 1, &v_iter)) {
-        CLIENT_ERR_PREFIXED("Error appending to BSON");
+        CLIENT_ERR(ERROR_PREFIX "Error appending to BSON");
         return false;
     }
 
@@ -247,25 +243,23 @@ bool mc_RangeOpts_to_FLE2RangeInsertSpec(const mc_RangeOpts_t *ro,
     if (ro->precision.set) {
         BSON_ASSERT(ro->precision.value <= INT32_MAX);
         if (!BSON_APPEND_INT32(&child, "precision", (int32_t)ro->precision.value)) {
-            CLIENT_ERR_PREFIXED("Error appending to BSON");
+            CLIENT_ERR(ERROR_PREFIX "Error appending to BSON");
             return false;
         }
     }
 
-    if (use_range_v2) {
-        if (!mc_RangeOpts_appendTrimFactor(ro, bson_iter_type(&v_iter), "trimFactor", &child, status, use_range_v2)) {
-            return false;
-        }
+    if (!mc_RangeOpts_appendTrimFactor(ro, bson_iter_type(&v_iter), "trimFactor", &child, status)) {
+        return false;
     }
     if (!bson_append_document_end(out, &child)) {
-        CLIENT_ERR_PREFIXED("Error appending to BSON");
+        CLIENT_ERR(ERROR_PREFIX "Error appending to BSON");
         return false;
     }
     return true;
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error appending min to FLE2RangeInsertSpec"
+#define ERROR_PREFIX "Error appending min to FLE2RangeInsertSpec: "
 
 bool mc_RangeOpts_appendMin(const mc_RangeOpts_t *ro,
                             bson_type_t valueType,
@@ -279,48 +273,48 @@ bool mc_RangeOpts_appendMin(const mc_RangeOpts_t *ro,
 
     if (ro->min.set) {
         if (bson_iter_type(&ro->min.value) != valueType) {
-            CLIENT_ERR_PREFIXED("expected matching 'min' and value type. Got range option "
-                                "'min' of type %s and value of type %s",
-                                mc_bson_type_to_string(bson_iter_type(&ro->min.value)),
-                                mc_bson_type_to_string(valueType));
+            CLIENT_ERR(ERROR_PREFIX "expected matching 'min' and value type. Got range option "
+                                    "'min' of type %s and value of type %s",
+                       mc_bson_type_to_string(bson_iter_type(&ro->min.value)),
+                       mc_bson_type_to_string(valueType));
             return false;
         }
         if (!bson_append_iter(out, fieldName, -1, &ro->min.value)) {
-            CLIENT_ERR_PREFIXED("failed to append BSON");
+            CLIENT_ERR(ERROR_PREFIX "failed to append BSON");
             return false;
         }
         return true;
     }
 
     if (valueType == BSON_TYPE_INT32 || valueType == BSON_TYPE_INT64 || valueType == BSON_TYPE_DATE_TIME) {
-        CLIENT_ERR_PREFIXED("Range option 'min' is required for type: %s", mc_bson_type_to_string(valueType));
+        CLIENT_ERR(ERROR_PREFIX "Range option 'min' is required for type: %s", mc_bson_type_to_string(valueType));
         return false;
     } else if (valueType == BSON_TYPE_DOUBLE) {
         if (!BSON_APPEND_DOUBLE(out, fieldName, -DBL_MAX)) {
-            CLIENT_ERR_PREFIXED("failed to append BSON");
+            CLIENT_ERR(ERROR_PREFIX "failed to append BSON");
             return false;
         }
     } else if (valueType == BSON_TYPE_DECIMAL128) {
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
         const bson_decimal128_t min = mc_dec128_to_bson_decimal128(MC_DEC128_LARGEST_NEGATIVE);
         if (!BSON_APPEND_DECIMAL128(out, fieldName, &min)) {
-            CLIENT_ERR_PREFIXED("failed to append BSON");
+            CLIENT_ERR(ERROR_PREFIX "failed to append BSON");
             return false;
         }
 #else  // ↑↑↑↑↑↑↑↑ With Decimal128 / Without ↓↓↓↓↓↓↓↓↓↓
-        CLIENT_ERR_PREFIXED("unsupported BSON type (Decimal128) for range: libmongocrypt "
-                            "was built without extended Decimal128 support");
+        CLIENT_ERR(ERROR_PREFIX "unsupported BSON type (Decimal128) for range: libmongocrypt "
+                                "was built without extended Decimal128 support");
         return false;
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
     } else {
-        CLIENT_ERR_PREFIXED("unsupported BSON type: %s for range", mc_bson_type_to_string(valueType));
+        CLIENT_ERR(ERROR_PREFIX "unsupported BSON type: %s for range", mc_bson_type_to_string(valueType));
         return false;
     }
     return true;
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error appending max to FLE2RangeInsertSpec"
+#define ERROR_PREFIX "Error appending max to FLE2RangeInsertSpec: "
 
 bool mc_RangeOpts_appendMax(const mc_RangeOpts_t *ro,
                             bson_type_t valueType,
@@ -334,56 +328,53 @@ bool mc_RangeOpts_appendMax(const mc_RangeOpts_t *ro,
 
     if (ro->max.set) {
         if (bson_iter_type(&ro->max.value) != valueType) {
-            CLIENT_ERR_PREFIXED("expected matching 'max' and value type. Got range option "
-                                "'max' of type %s and value of type %s",
-                                mc_bson_type_to_string(bson_iter_type(&ro->max.value)),
-                                mc_bson_type_to_string(valueType));
+            CLIENT_ERR(ERROR_PREFIX "expected matching 'max' and value type. Got range option "
+                                    "'max' of type %s and value of type %s",
+                       mc_bson_type_to_string(bson_iter_type(&ro->max.value)),
+                       mc_bson_type_to_string(valueType));
             return false;
         }
         if (!bson_append_iter(out, fieldName, -1, &ro->max.value)) {
-            CLIENT_ERR_PREFIXED("failed to append BSON");
+            CLIENT_ERR(ERROR_PREFIX "failed to append BSON");
             return false;
         }
         return true;
     }
 
     if (valueType == BSON_TYPE_INT32 || valueType == BSON_TYPE_INT64 || valueType == BSON_TYPE_DATE_TIME) {
-        CLIENT_ERR_PREFIXED("Range option 'max' is required for type: %s", mc_bson_type_to_string(valueType));
+        CLIENT_ERR(ERROR_PREFIX "Range option 'max' is required for type: %s", mc_bson_type_to_string(valueType));
         return false;
     } else if (valueType == BSON_TYPE_DOUBLE) {
         if (!BSON_APPEND_DOUBLE(out, fieldName, DBL_MAX)) {
-            CLIENT_ERR_PREFIXED("failed to append BSON");
+            CLIENT_ERR(ERROR_PREFIX "failed to append BSON");
             return false;
         }
     } else if (valueType == BSON_TYPE_DECIMAL128) {
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
         const bson_decimal128_t max = mc_dec128_to_bson_decimal128(MC_DEC128_LARGEST_POSITIVE);
         if (!BSON_APPEND_DECIMAL128(out, fieldName, &max)) {
-            CLIENT_ERR_PREFIXED("failed to append BSON");
+            CLIENT_ERR(ERROR_PREFIX "failed to append BSON");
             return false;
         }
 #else  // ↑↑↑↑↑↑↑↑ With Decimal128 / Without ↓↓↓↓↓↓↓↓↓↓
-        CLIENT_ERR_PREFIXED("unsupported BSON type (Decimal128) for range: libmongocrypt "
-                            "was built without extended Decimal128 support");
+        CLIENT_ERR(ERROR_PREFIX "unsupported BSON type (Decimal128) for range: libmongocrypt "
+                                "was built without extended Decimal128 support");
         return false;
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
     } else {
-        CLIENT_ERR_PREFIXED("unsupported BSON type: %s for range", mc_bson_type_to_string(valueType));
+        CLIENT_ERR(ERROR_PREFIX "unsupported BSON type: %s for range", mc_bson_type_to_string(valueType));
         return false;
     }
     return true;
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error in getNumberOfBits"
+#define ERROR_PREFIX "Error in getNumberOfBits: "
 
 // Used to calculate max trim factor. Returns the number of bits required to represent any number in
 // the domain.
-bool mc_getNumberOfBits(const mc_RangeOpts_t *ro,
-                        bson_type_t valueType,
-                        uint32_t *bitsOut,
-                        mongocrypt_status_t *status,
-                        bool use_range_v2) {
+static bool
+mc_getNumberOfBits(const mc_RangeOpts_t *ro, bson_type_t valueType, uint32_t *bitsOut, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(ro);
     BSON_ASSERT_PARAM(bitsOut);
 
@@ -450,13 +441,13 @@ bool mc_getNumberOfBits(const mc_RangeOpts_t *ro,
         }
         mc_getTypeInfoDouble_args_t args = {value, rmin, rmax, prec};
         mc_OSTType_Double out;
-        if (!mc_getTypeInfoDouble(args, &out, status, use_range_v2)) {
+        if (!mc_getTypeInfoDouble(args, &out, status)) {
             return false;
         }
         *bitsOut = 64 - (uint32_t)mc_count_leading_zeros_u64(out.max);
         return true;
     }
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
     else if (valueType == BSON_TYPE_DECIMAL128) {
         mc_dec128 value = MC_DEC128_ZERO;
         mc_optional_dec128_t rmin = {false, MC_DEC128_ZERO}, rmax = {false, MC_DEC128_ZERO};
@@ -469,26 +460,25 @@ bool mc_getNumberOfBits(const mc_RangeOpts_t *ro,
         }
         mc_getTypeInfoDecimal128_args_t args = {value, rmin, rmax, prec};
         mc_OSTType_Decimal128 out;
-        if (!mc_getTypeInfoDecimal128(args, &out, status, use_range_v2)) {
+        if (!mc_getTypeInfoDecimal128(args, &out, status)) {
             return false;
         }
         *bitsOut = 128 - (uint32_t)mc_count_leading_zeros_u128(out.max);
         return true;
     }
 #endif
-    CLIENT_ERR_PREFIXED("unsupported BSON type: %s for range", mc_bson_type_to_string(valueType));
+    CLIENT_ERR(ERROR_PREFIX "unsupported BSON type: %s for range", mc_bson_type_to_string(valueType));
     return false;
 }
 
 #undef ERROR_PREFIX
-#define ERROR_PREFIX "Error appending trim factor to FLE2RangeInsertSpec"
+#define ERROR_PREFIX "Error appending trim factor to FLE2RangeInsertSpec: "
 
 bool mc_RangeOpts_appendTrimFactor(const mc_RangeOpts_t *ro,
                                    bson_type_t valueType,
                                    const char *fieldName,
                                    bson_t *out,
-                                   mongocrypt_status_t *status,
-                                   bool use_range_v2) {
+                                   mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(ro);
     BSON_ASSERT_PARAM(fieldName);
     BSON_ASSERT_PARAM(out);
@@ -500,20 +490,20 @@ bool mc_RangeOpts_appendTrimFactor(const mc_RangeOpts_t *ro,
     }
 
     uint32_t nbits;
-    if (!mc_getNumberOfBits(ro, valueType, &nbits, status, use_range_v2)) {
+    if (!mc_getNumberOfBits(ro, valueType, &nbits, status)) {
         return false;
     }
     // if nbits = 0, we want to allow trim factor = 0.
     uint32_t test = nbits ? nbits : 1;
     if (mc_cmp_greater_equal_su(ro->trimFactor.value, test)) {
-        CLIENT_ERR_PREFIXED("Trim factor (%d) must be less than the total number of bits (%d) used to represent "
-                            "any element in the domain.",
-                            ro->trimFactor.value,
-                            nbits);
+        CLIENT_ERR(ERROR_PREFIX "Trim factor (%" PRId32 ") must be less than the total number of bits (%" PRIu32
+                                ") used to represent any element in the domain.",
+                   ro->trimFactor.value,
+                   nbits);
         return false;
     }
     if (!BSON_APPEND_INT32(out, fieldName, ro->trimFactor.value)) {
-        CLIENT_ERR_PREFIXED("failed to append BSON");
+        CLIENT_ERR(ERROR_PREFIX "failed to append BSON");
         return false;
     }
     return true;