libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

data/ext/libmongocrypt/libmongocrypt/src/mc-range-mincover-generator.template.h

@@ -17,20 +17,7 @@
 // mc-range-mincover-generator.template.h is meant to be included in another
 // source file.
 
-// TODO: replace `CONCAT` with `BSON_CONCAT` after libbson dependency is
-// upgraded to 1.20.0 or higher.
-#ifndef CONCAT
-#define CONCAT_1(a, b) a##b
-#define CONCAT(a, b) CONCAT_1 (a, b)
-#endif
-// TODO: replace `CONCAT3` with `BSON_CONCAT3` after libbson dependency is
-// upgraded to 1.20.0 or higher.
-#ifndef CONCAT3
-#define CONCAT3(a, b, c) CONCAT (a, CONCAT (b, c))
-#endif
-
-#if !(defined(UINT_T) && defined(UINT_C) && defined(UINT_FMT_S) && \
-      defined(DECORATE_NAME))
+#if !(defined(UINT_T) && defined(UINT_C) && defined(UINT_FMT_S) && defined(DECORATE_NAME))
 #ifdef __INTELLISENSE__
 #define UINT_T uint32_t
 #define UINT_C UINT32_C
@@ -41,9 +28,9 @@
 #endif
 #endif
 
-#define BITS (sizeof (UINT_T) * CHAR_BIT)
+#define BITS (sizeof(UINT_T) * CHAR_BIT)
 
-#define ZERO UINT_C (0)
+#define ZERO UINT_C(0)
 
 // Default for UINT_FMT_ARG
 #ifndef UINT_FMT_ARG
@@ -56,7 +43,7 @@
 #endif
 
 #ifndef MC_UINT_MAX
-#define MC_UINT_MAX ~(UINT_C (0))
+#define MC_UINT_MAX ~(UINT_C(0))
 #endif
 
 // Default addition
@@ -69,227 +56,216 @@
 
 // Default lshift (also handles negatives as right-shift)
 #ifndef UINT_LSHIFT
-static inline UINT_T
-DECORATE_NAME (_mc_default_lshift) (UINT_T lhs, int off)
-{
-   if (off < 0) {
-      return lhs >> -off;
-   } else {
-      return lhs << off;
-   }
+static inline UINT_T DECORATE_NAME(_mc_default_lshift)(UINT_T lhs, int off) {
+    if (off < 0) {
+        return lhs >> -off;
+    } else {
+        return lhs << off;
+    }
 }
-#define UINT_LSHIFT DECORATE_NAME (_mc_default_lshift)
+
+#define UINT_LSHIFT DECORATE_NAME(_mc_default_lshift)
 #endif
 
 #ifndef UINT_BITOR
 #define UINT_BITOR(A, B) ((A) | (B))
 #endif
 
-static inline int
-DECORATE_NAME (_mc_compare) (UINT_T lhs, UINT_T rhs)
-{
-   if (UINT_LESSTHAN (lhs, rhs)) {
-      return -1;
-   } else if (UINT_LESSTHAN (rhs, lhs)) {
-      return 1;
-   } else {
-      return 0;
-   }
+static inline int DECORATE_NAME(_mc_compare)(UINT_T lhs, UINT_T rhs) {
+    if (UINT_LESSTHAN(lhs, rhs)) {
+        return -1;
+    } else if (UINT_LESSTHAN(rhs, lhs)) {
+        return 1;
+    } else {
+        return 0;
+    }
 }
 
-#define UINT_COMPARE DECORATE_NAME (_mc_compare)
+#define UINT_COMPARE DECORATE_NAME(_mc_compare)
 
 // MinCoverGenerator models the MinCoverGenerator type added in
 // SERVER-68600.
 typedef struct {
-   UINT_T _rangeMin;
-   UINT_T _rangeMax;
-   size_t _sparsity;
-   // _maxlen is the maximum bit length of edges in the mincover.
-   size_t _maxlen;
-} DECORATE_NAME (MinCoverGenerator);
-
-static inline DECORATE_NAME (MinCoverGenerator) *
-   DECORATE_NAME (MinCoverGenerator_new) (UINT_T rangeMin,
-                                          UINT_T rangeMax,
-                                          UINT_T max,
-                                          size_t sparsity,
-                                          mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (status);
-
-   if (UINT_COMPARE (rangeMin, rangeMax) > 0) {
-      CLIENT_ERR ("Range min (%" UINT_FMT_S
-                  ") must be less than or equal to range max (%" UINT_FMT_S
-                  ") for range search",
-                  UINT_FMT_ARG (rangeMin),
-                  UINT_FMT_ARG (rangeMax));
-      return NULL;
-   }
-   if (UINT_COMPARE (rangeMax, max) > 0) {
-      CLIENT_ERR ("Range max (%" UINT_FMT_S
-                  ") must be less than or equal to max (%" UINT_FMT_S
-                  ") for range search",
-                  UINT_FMT_ARG (rangeMax),
-                  UINT_FMT_ARG (max));
-      return NULL;
-   }
-
-   if (sparsity == 0) {
-      CLIENT_ERR ("Sparsity must be > 0");
-      return NULL;
-   }
-   DECORATE_NAME (MinCoverGenerator) *mcg =
-      bson_malloc0 (sizeof (DECORATE_NAME (MinCoverGenerator)));
-   mcg->_rangeMin = rangeMin;
-   mcg->_rangeMax = rangeMax;
-   mcg->_maxlen = (size_t) BITS - DECORATE_NAME (mc_count_leading_zeros) (max);
-   mcg->_sparsity = sparsity;
-   return mcg;
+    UINT_T _rangeMin;
+    UINT_T _rangeMax;
+    size_t _sparsity;
+    int32_t _trimFactor;
+    // _maxlen is the maximum bit length of edges in the mincover.
+    size_t _maxlen;
+} DECORATE_NAME(MinCoverGenerator);
+
+static inline DECORATE_NAME(MinCoverGenerator)
+    * DECORATE_NAME(MinCoverGenerator_new)(UINT_T rangeMin,
+                                           UINT_T rangeMax,
+                                           UINT_T max,
+                                           size_t sparsity,
+                                           mc_optional_int32_t opt_trimFactor,
+                                           mongocrypt_status_t *status,
+                                           bool use_range_v2) {
+    BSON_ASSERT_PARAM(status);
+
+    if (UINT_COMPARE(rangeMin, rangeMax) > 0) {
+        CLIENT_ERR("Range min (%" UINT_FMT_S ") must be less than or equal to range max (%" UINT_FMT_S
+                   ") for range search",
+                   UINT_FMT_ARG(rangeMin),
+                   UINT_FMT_ARG(rangeMax));
+        return NULL;
+    }
+    if (UINT_COMPARE(rangeMax, max) > 0) {
+        CLIENT_ERR("Range max (%" UINT_FMT_S ") must be less than or equal to max (%" UINT_FMT_S ") for range search",
+                   UINT_FMT_ARG(rangeMax),
+                   UINT_FMT_ARG(max));
+        return NULL;
+    }
+
+    if (sparsity == 0) {
+        CLIENT_ERR("Sparsity must be > 0");
+        return NULL;
+    }
+    size_t maxlen = (size_t)BITS - DECORATE_NAME(mc_count_leading_zeros)(max);
+    int32_t trimFactor = trimFactorDefault(maxlen, opt_trimFactor, use_range_v2);
+    if (trimFactor != 0 && bson_cmp_greater_equal_su(trimFactor, maxlen)) {
+        CLIENT_ERR("Trim factor must be less than the number of bits (%ld) used to represent an element of the domain, "
+                   "but got %" PRId32,
+                   maxlen,
+                   trimFactor);
+        return NULL;
+    }
+    if (trimFactor < 0) {
+        CLIENT_ERR("Trim factor must be >= 0, but got (%" PRId32 ")", trimFactor);
+        return NULL;
+    }
+    DECORATE_NAME(MinCoverGenerator) *mcg = bson_malloc0(sizeof(DECORATE_NAME(MinCoverGenerator)));
+    mcg->_rangeMin = rangeMin;
+    mcg->_rangeMax = rangeMax;
+    mcg->_maxlen = (size_t)BITS - DECORATE_NAME(mc_count_leading_zeros)(max);
+    mcg->_sparsity = sparsity;
+    mcg->_trimFactor = trimFactor;
+    return mcg;
 }
 
-static inline void
-DECORATE_NAME (MinCoverGenerator_destroy) (DECORATE_NAME (MinCoverGenerator) *
-                                           mcg)
-{
-   bson_free (mcg);
+static inline void DECORATE_NAME(MinCoverGenerator_destroy)(DECORATE_NAME(MinCoverGenerator) * mcg) {
+    bson_free(mcg);
 }
 
 // applyMask applies a mask of 1 bits starting from the right.
 // Bits 0 to bit-1 are replaced with 1. Other bits are left as-is.
-static inline UINT_T
-DECORATE_NAME (applyMask) (UINT_T value, size_t maskedBits)
-{
-   const UINT_T ones = MC_UINT_MAX;
+static inline UINT_T DECORATE_NAME(applyMask)(UINT_T value, size_t maskedBits) {
+    const UINT_T ones = MC_UINT_MAX;
 
-   BSON_ASSERT (maskedBits <= (size_t) BITS);
-   BSON_ASSERT (maskedBits >= 0);
+    BSON_ASSERT(maskedBits <= (size_t)BITS);
+    BSON_ASSERT(maskedBits >= 0);
 
-   if (maskedBits == 0) {
-      return value;
-   }
+    if (maskedBits == 0) {
+        return value;
+    }
 
-   const size_t shift = ((size_t) BITS - maskedBits);
-   const UINT_T mask = UINT_LSHIFT (ones, -(int) shift);
-   return UINT_BITOR (value, mask);
+    const size_t shift = ((size_t)BITS - maskedBits);
+    const UINT_T mask = UINT_LSHIFT(ones, -(int)shift);
+    return UINT_BITOR(value, mask);
 }
 
-static inline bool
-DECORATE_NAME (MinCoverGenerator_isLevelStored) (
-   DECORATE_NAME (MinCoverGenerator) * mcg, size_t maskedBits)
-{
-   BSON_ASSERT_PARAM (mcg);
-   size_t level = mcg->_maxlen - maskedBits;
-   return 0 == maskedBits || 0 == (level % mcg->_sparsity);
+static inline bool DECORATE_NAME(MinCoverGenerator_isLevelStored)(DECORATE_NAME(MinCoverGenerator) * mcg,
+                                                                  size_t maskedBits) {
+    BSON_ASSERT_PARAM(mcg);
+    size_t level = mcg->_maxlen - maskedBits;
+    BSON_ASSERT(bson_in_range_size_t_signed(mcg->_trimFactor));
+    size_t trimFactor_sz = (size_t)mcg->_trimFactor;
+    return 0 == maskedBits || (level >= trimFactor_sz && 0 == (level % mcg->_sparsity));
 }
 
 char *
-DECORATE_NAME (MinCoverGenerator_toString) (
-   DECORATE_NAME (MinCoverGenerator) * mcg, UINT_T start, size_t maskedBits)
-{
-   BSON_ASSERT_PARAM (mcg);
-   BSON_ASSERT (maskedBits <= mcg->_maxlen);
-   BSON_ASSERT (maskedBits <= (size_t) BITS);
-   BSON_ASSERT (maskedBits >= 0);
-
-   if (maskedBits == mcg->_maxlen) {
-      return bson_strdup ("root");
-   }
-
-   UINT_T shifted = UINT_LSHIFT (start, -(int) maskedBits);
-   mc_bitstring valueBin = DECORATE_NAME (mc_convert_to_bitstring) (shifted);
-   char *ret =
-      bson_strndup (valueBin.str + ((size_t) BITS - mcg->_maxlen + maskedBits),
-                    mcg->_maxlen + maskedBits);
-   return ret;
+DECORATE_NAME(MinCoverGenerator_toString)(DECORATE_NAME(MinCoverGenerator) * mcg, UINT_T start, size_t maskedBits) {
+    BSON_ASSERT_PARAM(mcg);
+    BSON_ASSERT(maskedBits <= mcg->_maxlen);
+    BSON_ASSERT(maskedBits <= (size_t)BITS);
+    BSON_ASSERT(maskedBits >= 0);
+
+    if (maskedBits == mcg->_maxlen) {
+        return bson_strdup("root");
+    }
+
+    UINT_T shifted = UINT_LSHIFT(start, -(int)maskedBits);
+    mc_bitstring valueBin = DECORATE_NAME(mc_convert_to_bitstring)(shifted);
+    char *ret = bson_strndup(valueBin.str + ((size_t)BITS - mcg->_maxlen + maskedBits), mcg->_maxlen + maskedBits);
+    return ret;
+}
+
+static inline void DECORATE_NAME(MinCoverGenerator_minCoverRec)(DECORATE_NAME(MinCoverGenerator) * mcg,
+                                                                mc_array_t *c,
+                                                                UINT_T blockStart,
+                                                                size_t maskedBits) {
+    BSON_ASSERT_PARAM(mcg);
+    BSON_ASSERT_PARAM(c);
+    const UINT_T blockEnd = DECORATE_NAME(applyMask)(blockStart, maskedBits);
+
+    if (UINT_COMPARE(blockEnd, mcg->_rangeMin) < 0 || UINT_COMPARE(blockStart, mcg->_rangeMax) > 0) {
+        return;
+    }
+
+    if (UINT_COMPARE(blockStart, mcg->_rangeMin) >= 0 && UINT_COMPARE(blockEnd, mcg->_rangeMax) <= 0
+        && DECORATE_NAME(MinCoverGenerator_isLevelStored)(mcg, maskedBits)) {
+        char *edge = DECORATE_NAME(MinCoverGenerator_toString)(mcg, blockStart, maskedBits);
+        _mc_array_append_val(c, edge);
+        return;
+    }
+
+    BSON_ASSERT(maskedBits > 0);
+
+    const size_t newBits = maskedBits - 1u;
+    DECORATE_NAME(MinCoverGenerator_minCoverRec)(mcg, c, blockStart, newBits);
+    DECORATE_NAME(MinCoverGenerator_minCoverRec)
+    (mcg, c, UINT_BITOR(blockStart, UINT_LSHIFT(UINT_C(1), (int)newBits)), newBits);
 }
 
-static inline void
-DECORATE_NAME (MinCoverGenerator_minCoverRec) (
-   DECORATE_NAME (MinCoverGenerator) * mcg,
-   mc_array_t *c,
-   UINT_T blockStart,
-   size_t maskedBits)
-{
-   BSON_ASSERT_PARAM (mcg);
-   BSON_ASSERT_PARAM (c);
-   const UINT_T blockEnd = DECORATE_NAME (applyMask) (blockStart, maskedBits);
-
-   if (UINT_COMPARE (blockEnd, mcg->_rangeMin) < 0 ||
-       UINT_COMPARE (blockStart, mcg->_rangeMax) > 0) {
-      return;
-   }
-
-   if (UINT_COMPARE (blockStart, mcg->_rangeMin) >= 0 &&
-       UINT_COMPARE (blockEnd, mcg->_rangeMax) <= 0 &&
-       DECORATE_NAME (MinCoverGenerator_isLevelStored) (mcg, maskedBits)) {
-      char *edge = DECORATE_NAME (MinCoverGenerator_toString) (
-         mcg, blockStart, maskedBits);
-      _mc_array_append_val (c, edge);
-      return;
-   }
-
-   BSON_ASSERT (maskedBits > 0);
-
-   const size_t newBits = maskedBits - 1u;
-   DECORATE_NAME (MinCoverGenerator_minCoverRec) (mcg, c, blockStart, newBits);
-   DECORATE_NAME (MinCoverGenerator_minCoverRec)
-   (mcg,
-    c,
-    UINT_BITOR (blockStart, UINT_LSHIFT (UINT_C (1), (int) newBits)),
-    newBits);
+static inline mc_mincover_t *DECORATE_NAME(MinCoverGenerator_minCover)(DECORATE_NAME(MinCoverGenerator) * mcg) {
+    BSON_ASSERT_PARAM(mcg);
+    mc_mincover_t *mc = mc_mincover_new();
+    DECORATE_NAME(MinCoverGenerator_minCoverRec)
+    (mcg, &mc->mincover, ZERO, mcg->_maxlen);
+    return mc;
 }
 
-static inline mc_mincover_t *
-DECORATE_NAME (MinCoverGenerator_minCover) (DECORATE_NAME (MinCoverGenerator) *
-                                            mcg)
-{
-   BSON_ASSERT_PARAM (mcg);
-   mc_mincover_t *mc = mc_mincover_new ();
-   DECORATE_NAME (MinCoverGenerator_minCoverRec)
-   (mcg, &mc->mincover, ZERO, mcg->_maxlen);
-   return mc;
+static inline int32_t DECORATE_NAME(MinCoverGenerator_usedTrimFactor)(DECORATE_NAME(MinCoverGenerator) * mcg) {
+    BSON_ASSERT_PARAM(mcg);
+    return mcg->_trimFactor;
 }
 
 // adjustBounds increments *lowerBound if includeLowerBound is false and
 // decrements *upperBound if includeUpperBound is false.
 // lowerBound, min, upperBound, and max are expected to come from the result
 // of mc_getTypeInfo.
-static bool
-DECORATE_NAME (adjustBounds) (UINT_T *lowerBound,
-                              bool includeLowerBound,
-                              UINT_T min,
-                              UINT_T *upperBound,
-                              bool includeUpperBound,
-                              UINT_T max,
-                              mongocrypt_status_t *status)
-{
-   BSON_ASSERT_PARAM (lowerBound);
-   BSON_ASSERT_PARAM (upperBound);
-
-   if (!includeLowerBound) {
-      if (UINT_COMPARE (*lowerBound, max) >= 0) {
-         CLIENT_ERR ("Lower bound (%" UINT_FMT_S
-                     ") must be less than the range maximum (%" UINT_FMT_S
-                     ") if lower bound is excluded from range.",
-                     UINT_FMT_ARG (*lowerBound),
-                     UINT_FMT_ARG (max));
-         return false;
-      }
-      *lowerBound = UINT_ADD (*lowerBound, UINT_C (1));
-   }
-   if (!includeUpperBound) {
-      if (UINT_COMPARE (*upperBound, min) <= 0) {
-         CLIENT_ERR ("Upper bound (%" UINT_FMT_S
-                     ") must be greater than the range minimum (%" UINT_FMT_S
-                     ") if upper bound is excluded from range.",
-                     UINT_FMT_ARG (*upperBound),
-                     UINT_FMT_ARG (min));
-         return false;
-      }
-      *upperBound = UINT_SUB (*upperBound, UINT_C (1));
-   }
-   return true;
+static bool DECORATE_NAME(adjustBounds)(UINT_T *lowerBound,
+                                        bool includeLowerBound,
+                                        UINT_T min,
+                                        UINT_T *upperBound,
+                                        bool includeUpperBound,
+                                        UINT_T max,
+                                        mongocrypt_status_t *status) {
+    BSON_ASSERT_PARAM(lowerBound);
+    BSON_ASSERT_PARAM(upperBound);
+
+    if (!includeLowerBound) {
+        if (UINT_COMPARE(*lowerBound, max) >= 0) {
+            CLIENT_ERR("Lower bound (%" UINT_FMT_S ") must be less than the range maximum (%" UINT_FMT_S
+                       ") if lower bound is excluded from range.",
+                       UINT_FMT_ARG(*lowerBound),
+                       UINT_FMT_ARG(max));
+            return false;
+        }
+        *lowerBound = UINT_ADD(*lowerBound, UINT_C(1));
+    }
+    if (!includeUpperBound) {
+        if (UINT_COMPARE(*upperBound, min) <= 0) {
+            CLIENT_ERR("Upper bound (%" UINT_FMT_S ") must be greater than the range minimum (%" UINT_FMT_S
+                       ") if upper bound is excluded from range.",
+                       UINT_FMT_ARG(*upperBound),
+                       UINT_FMT_ARG(min));
+            return false;
+        }
+        *upperBound = UINT_SUB(*upperBound, UINT_C(1));
+    }
+    return true;
 }
 
 #undef UINT_T

data/ext/libmongocrypt/libmongocrypt/src/mc-range-mincover-private.h

@@ -17,96 +17,97 @@
 #ifndef MC_RANGE_MINCOVER_PRIVATE_H
 #define MC_RANGE_MINCOVER_PRIVATE_H
 
-#include <stddef.h> // size_t
-#include <stdint.h>
+#include "mc-dec128.h"
 #include "mc-optional-private.h"
 #include "mongocrypt-status-private.h"
-#include "mc-dec128.h"
+#include <stddef.h> // size_t
+#include <stdint.h>
 
 // mc_mincover_t represents the results of the mincover algorithm.
 typedef struct _mc_mincover_t mc_mincover_t;
 
 // mc_mincover_get returns edge at an index.
 // Returns NULL if `index` is out of range.
-const char *
-mc_mincover_get (mc_mincover_t *mincover, size_t index);
+const char *mc_mincover_get(mc_mincover_t *mincover, size_t index);
 
 // mc_mincover_len returns the number of represented mincover.
-size_t
-mc_mincover_len (mc_mincover_t *mincover);
+size_t mc_mincover_len(mc_mincover_t *mincover);
+
+// Return the trimFactor that was used to generate this mincover.
+int32_t mc_mincover_get_used_trimFactor(const mc_mincover_t *mincover);
 
 // mc_mincover_destroys frees `mincover`.
-void
-mc_mincover_destroy (mc_mincover_t *mincover);
+void mc_mincover_destroy(mc_mincover_t *mincover);
 
 typedef struct {
-   int32_t lowerBound;
-   bool includeLowerBound;
-   int32_t upperBound;
-   bool includeUpperBound;
-   mc_optional_int32_t min;
-   mc_optional_int32_t max;
-   size_t sparsity;
+    int32_t lowerBound;
+    bool includeLowerBound;
+    int32_t upperBound;
+    bool includeUpperBound;
+    mc_optional_int32_t min;
+    mc_optional_int32_t max;
+    size_t sparsity;
+    mc_optional_int32_t trimFactor;
 } mc_getMincoverInt32_args_t;
 
 // mc_getMincoverInt32 implements the Mincover Generation algorithm described in
 // SERVER-68600 for int32_t.
-mc_mincover_t *
-mc_getMincoverInt32 (mc_getMincoverInt32_args_t args,
-                     mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
+mc_mincover_t *mc_getMincoverInt32(mc_getMincoverInt32_args_t args,
+                                   mongocrypt_status_t *status,
+                                   bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
 
 typedef struct {
-   int64_t lowerBound;
-   bool includeLowerBound;
-   int64_t upperBound;
-   bool includeUpperBound;
-   mc_optional_int64_t min;
-   mc_optional_int64_t max;
-   size_t sparsity;
+    int64_t lowerBound;
+    bool includeLowerBound;
+    int64_t upperBound;
+    bool includeUpperBound;
+    mc_optional_int64_t min;
+    mc_optional_int64_t max;
+    size_t sparsity;
+    mc_optional_int32_t trimFactor;
 } mc_getMincoverInt64_args_t;
 
 // mc_getMincoverInt64 implements the Mincover Generation algorithm described in
 // SERVER-68600 for int64_t.
-mc_mincover_t *
-mc_getMincoverInt64 (mc_getMincoverInt64_args_t args,
-                     mongocrypt_status_t *status) MONGOCRYPT_WARN_UNUSED_RESULT;
+mc_mincover_t *mc_getMincoverInt64(mc_getMincoverInt64_args_t args,
+                                   mongocrypt_status_t *status,
+                                   bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
 
 typedef struct {
-   double lowerBound;
-   bool includeLowerBound;
-   double upperBound;
-   bool includeUpperBound;
-   size_t sparsity;
-   mc_optional_double_t min;
-   mc_optional_double_t max;
-   mc_optional_uint32_t precision;
+    double lowerBound;
+    bool includeLowerBound;
+    double upperBound;
+    bool includeUpperBound;
+    size_t sparsity;
+    mc_optional_double_t min;
+    mc_optional_double_t max;
+    mc_optional_int32_t precision;
+    mc_optional_int32_t trimFactor;
 } mc_getMincoverDouble_args_t;
 
 // 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)
-   MONGOCRYPT_WARN_UNUSED_RESULT;
-
+mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args,
+                                    mongocrypt_status_t *status,
+                                    bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
 
 #if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 typedef struct {
-   mc_dec128 lowerBound;
-   bool includeLowerBound;
-   mc_dec128 upperBound;
-   bool includeUpperBound;
-   size_t sparsity;
-   mc_optional_dec128_t min, max;
-   mc_optional_uint32_t precision;
+    mc_dec128 lowerBound;
+    bool includeLowerBound;
+    mc_dec128 upperBound;
+    bool includeUpperBound;
+    size_t sparsity;
+    mc_optional_dec128_t min, max;
+    mc_optional_int32_t precision;
+    mc_optional_int32_t trimFactor;
 } mc_getMincoverDecimal128_args_t;
 
 // mc_getMincoverDecimal128 implements the Mincover Generation algorithm
 // described in SERVER-68600 for Decimal128 (as mc_dec128).
-mc_mincover_t *
-mc_getMincoverDecimal128 (mc_getMincoverDecimal128_args_t args,
-                          mongocrypt_status_t *status)
-   MONGOCRYPT_WARN_UNUSED_RESULT;
+mc_mincover_t *mc_getMincoverDecimal128(mc_getMincoverDecimal128_args_t args,
+                                        mongocrypt_status_t *status,
+                                        bool use_range_v2) MONGOCRYPT_WARN_UNUSED_RESULT;
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
 #endif /* MC_RANGE_MINCOVER_PRIVATE_H */