libmongocrypt-helper 1.7.4.0.1002 → 1.11.0.0.1001

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

@@ -20,52 +20,49 @@
 
 #include "mc-array-private.h"
 #include "mc-range-edge-generation-private.h" // mc_count_leading_zeros_u32
-#include "mc-range-encoding-private.h"        // mc_getTypeInfo32
+#include "mc-range-encoding-private.h"        // mc_getTypeInfo32, trimFactorDefault
 #include "mc-range-mincover-private.h"
 #include "mongocrypt-private.h"
 
 struct _mc_mincover_t {
-   /* mincover is an array of `char*` edge strings. */
-   mc_array_t mincover;
+    /* mincover is an array of `char*` edge strings. */
+    mc_array_t mincover;
+    int32_t usedTrimFactor; // The `trimFactor` that was used to produce this mincover.
 };
 
-static mc_mincover_t *
-mc_mincover_new (void)
-{
-   mc_mincover_t *mincover = bson_malloc0 (sizeof (mc_mincover_t));
-   _mc_array_init (&mincover->mincover, sizeof (char *));
-   return mincover;
+static mc_mincover_t *mc_mincover_new(void) {
+    mc_mincover_t *mincover = bson_malloc0(sizeof(mc_mincover_t));
+    _mc_array_init(&mincover->mincover, sizeof(char *));
+    return mincover;
 }
 
-const char *
-mc_mincover_get (mc_mincover_t *mincover, size_t index)
-{
-   BSON_ASSERT_PARAM (mincover);
-   if (mincover->mincover.len == 0 || index > mincover->mincover.len - 1u) {
-      return NULL;
-   }
-   return _mc_array_index (&mincover->mincover, char *, index);
+const char *mc_mincover_get(mc_mincover_t *mincover, size_t index) {
+    BSON_ASSERT_PARAM(mincover);
+    if (mincover->mincover.len == 0 || index > mincover->mincover.len - 1u) {
+        return NULL;
+    }
+    return _mc_array_index(&mincover->mincover, char *, index);
 }
 
-size_t
-mc_mincover_len (mc_mincover_t *mincover)
-{
-   BSON_ASSERT_PARAM (mincover);
-   return mincover->mincover.len;
+size_t mc_mincover_len(mc_mincover_t *mincover) {
+    BSON_ASSERT_PARAM(mincover);
+    return mincover->mincover.len;
 }
 
-void
-mc_mincover_destroy (mc_mincover_t *mincover)
-{
-   if (NULL == mincover) {
-      return;
-   }
-   for (size_t i = 0; i < mincover->mincover.len; i++) {
-      char *val = _mc_array_index (&mincover->mincover, char *, i);
-      bson_free (val);
-   }
-   _mc_array_destroy (&mincover->mincover);
-   bson_free (mincover);
+int32_t mc_mincover_get_used_trimFactor(const mc_mincover_t *mincover) {
+    return mincover->usedTrimFactor;
+}
+
+void mc_mincover_destroy(mc_mincover_t *mincover) {
+    if (NULL == mincover) {
+        return;
+    }
+    for (size_t i = 0; i < mincover->mincover.len; i++) {
+        char *val = _mc_array_index(&mincover->mincover, char *, i);
+        bson_free(val);
+    }
+    _mc_array_destroy(&mincover->mincover);
+    bson_free(mincover);
 }
 
 #define UINT_T uint32_t
@@ -86,9 +83,9 @@ mc_mincover_destroy (mc_mincover_t *mincover)
 #define UINT_T mlib_int128
 #define UINT_C MLIB_INT128
 #define UINT_FMT_S "s"
-#define UINT_FMT_ARG(X) (mlib_int128_format (X).str)
+#define UINT_FMT_ARG(X) (mlib_int128_format(X).str)
 #define DECORATE_NAME(N) N##_u128
-#define UINT_LESSTHAN(L, R) (mlib_int128_ucmp (L, R) < 0)
+#define UINT_LESSTHAN(L, R) (mlib_int128_ucmp(L, R) < 0)
 #define UINT_ADD mlib_int128_add
 #define UINT_SUB mlib_int128_sub
 #define UINT_LSHIFT mlib_int128_lshift
@@ -97,245 +94,196 @@ mc_mincover_destroy (mc_mincover_t *mincover)
 #include "mc-range-mincover-generator.template.h"
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
-
 // Check bounds and return an error message including the original inputs.
 #define IDENTITY(X) X
 #define LESSTHAN(L, R) ((L) < (R))
-#define CHECK_BOUNDS(args, FMT, FormatArg, LessThan)                           \
-   if (1) {                                                                    \
-      if ((args).min.set) {                                                    \
-         if (LessThan ((args).upperBound, (args).min.value)) {                 \
-            CLIENT_ERR (                                                       \
-               "Upper bound (%" FMT                                            \
-               ") must be greater than or equal to the range minimum (%" FMT   \
-               ")",                                                            \
-               FormatArg ((args).upperBound),                                  \
-               FormatArg ((args).min.value));                                  \
-            return false;                                                      \
-         }                                                                     \
-         if (!(args).includeUpperBound &&                                      \
-             !LessThan ((args.min.value), (args.upperBound))) {                \
-            CLIENT_ERR ("Upper bound (%" FMT                                   \
-                        ") must be greater than the range minimum (%" FMT      \
-                        ") if upper bound is excluded from range",             \
-                        FormatArg ((args).upperBound),                         \
-                        FormatArg ((args).min.value));                         \
-            return false;                                                      \
-         }                                                                     \
-      }                                                                        \
-      if ((args).max.set) {                                                    \
-         if (LessThan ((args).max.value, (args).lowerBound)) {                 \
-            CLIENT_ERR (                                                       \
-               "Lower bound (%" FMT                                            \
-               ") must be less than or equal to the range maximum (%" FMT ")", \
-               FormatArg ((args).lowerBound),                                  \
-               FormatArg ((args).max.value));                                  \
-            return false;                                                      \
-         }                                                                     \
-         if (!(args).includeLowerBound &&                                      \
-             !LessThan ((args).lowerBound, (args).max.value)) {                \
-            CLIENT_ERR ("Lower bound (%" FMT                                   \
-                        ") must be less than the range maximum (%" FMT         \
-                        ") if lower bound is excluded from range",             \
-                        FormatArg ((args).lowerBound),                         \
-                        FormatArg ((args).max.value));                         \
-            return false;                                                      \
-         }                                                                     \
-      }                                                                        \
-   } else                                                                      \
-      (void) 0
+#define CHECK_BOUNDS(args, FMT, FormatArg, LessThan)                                                                   \
+    if (1) {                                                                                                           \
+        if ((args).min.set) {                                                                                          \
+            if (LessThan((args).upperBound, (args).min.value)) {                                                       \
+                CLIENT_ERR("Upper bound (%" FMT ") must be greater than or equal to the range minimum (%" FMT ")",     \
+                           FormatArg((args).upperBound),                                                               \
+                           FormatArg((args).min.value));                                                               \
+                return false;                                                                                          \
+            }                                                                                                          \
+            if (!(args).includeUpperBound && !LessThan((args.min.value), (args.upperBound))) {                         \
+                CLIENT_ERR("Upper bound (%" FMT ") must be greater than the range minimum (%" FMT                      \
+                           ") if upper bound is excluded from range",                                                  \
+                           FormatArg((args).upperBound),                                                               \
+                           FormatArg((args).min.value));                                                               \
+                return false;                                                                                          \
+            }                                                                                                          \
+        }                                                                                                              \
+        if ((args).max.set) {                                                                                          \
+            if (LessThan((args).max.value, (args).lowerBound)) {                                                       \
+                CLIENT_ERR("Lower bound (%" FMT ") must be less than or equal to the range maximum (%" FMT ")",        \
+                           FormatArg((args).lowerBound),                                                               \
+                           FormatArg((args).max.value));                                                               \
+                return false;                                                                                          \
+            }                                                                                                          \
+            if (!(args).includeLowerBound && !LessThan((args).lowerBound, (args).max.value)) {                         \
+                CLIENT_ERR("Lower bound (%" FMT ") must be less than the range maximum (%" FMT                         \
+                           ") if lower bound is excluded from range",                                                  \
+                           FormatArg((args).lowerBound),                                                               \
+                           FormatArg((args).max.value));                                                               \
+                return false;                                                                                          \
+            }                                                                                                          \
+        }                                                                                                              \
+    } else                                                                                                             \
+        (void)0
 
-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;
-   if (!mc_getTypeInfo32 ((mc_getTypeInfo32_args_t){.min = args.min,
-                                                    .max = args.max,
-                                                    .value = args.lowerBound},
+mc_mincover_t *mc_getMincoverInt32(mc_getMincoverInt32_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+    BSON_ASSERT_PARAM(status);
+    CHECK_BOUNDS(args, PRId32, IDENTITY, LESSTHAN);
+    mc_OSTType_Int32 a, b;
+    if (!mc_getTypeInfo32((mc_getTypeInfo32_args_t){.min = args.min, .max = args.max, .value = args.lowerBound},
                           &a,
                           status)) {
-      return NULL;
-   }
-   if (!mc_getTypeInfo32 ((mc_getTypeInfo32_args_t){.min = args.min,
-                                                    .max = args.max,
-                                                    .value = args.upperBound},
+        return NULL;
+    }
+    if (!mc_getTypeInfo32((mc_getTypeInfo32_args_t){.min = args.min, .max = args.max, .value = args.upperBound},
                           &b,
                           status)) {
-      return NULL;
-   }
+        return NULL;
+    }
 
-   BSON_ASSERT (a.min == b.min);
-   BSON_ASSERT (a.max == b.max);
+    BSON_ASSERT(a.min == b.min);
+    BSON_ASSERT(a.max == b.max);
 
-   if (!adjustBounds_u32 (&a.value,
-                          args.includeLowerBound,
-                          a.min,
-                          &b.value,
-                          args.includeUpperBound,
-                          b.max,
-                          status)) {
-      return NULL;
-   }
+    if (!adjustBounds_u32(&a.value, args.includeLowerBound, a.min, &b.value, args.includeUpperBound, b.max, status)) {
+        return NULL;
+    }
 
-   MinCoverGenerator_u32 *mcg = MinCoverGenerator_new_u32 (
-      a.value, b.value, a.max, args.sparsity, status);
-   if (!mcg) {
-      return NULL;
-   }
-   mc_mincover_t *mc = MinCoverGenerator_minCover_u32 (mcg);
-   MinCoverGenerator_destroy_u32 (mcg);
-   return mc;
+    MinCoverGenerator_u32 *mcg =
+        MinCoverGenerator_new_u32(a.value, b.value, a.max, args.sparsity, args.trimFactor, status, use_range_v2);
+    if (!mcg) {
+        return NULL;
+    }
+    mc_mincover_t *mc = MinCoverGenerator_minCover_u32(mcg);
+    mc->usedTrimFactor = MinCoverGenerator_usedTrimFactor_u32(mcg);
+    MinCoverGenerator_destroy_u32(mcg);
+    return mc;
 }
 
-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;
-   if (!mc_getTypeInfo64 ((mc_getTypeInfo64_args_t){.min = args.min,
-                                                    .max = args.max,
-                                                    .value = args.lowerBound},
+mc_mincover_t *mc_getMincoverInt64(mc_getMincoverInt64_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+    BSON_ASSERT_PARAM(status);
+    CHECK_BOUNDS(args, PRId64, IDENTITY, LESSTHAN);
+    mc_OSTType_Int64 a, b;
+    if (!mc_getTypeInfo64((mc_getTypeInfo64_args_t){.min = args.min, .max = args.max, .value = args.lowerBound},
                           &a,
                           status)) {
-      return NULL;
-   }
-   if (!mc_getTypeInfo64 ((mc_getTypeInfo64_args_t){.min = args.min,
-                                                    .max = args.max,
-                                                    .value = args.upperBound},
+        return NULL;
+    }
+    if (!mc_getTypeInfo64((mc_getTypeInfo64_args_t){.min = args.min, .max = args.max, .value = args.upperBound},
                           &b,
                           status)) {
-      return NULL;
-   }
+        return NULL;
+    }
 
-   BSON_ASSERT (a.min == b.min);
-   BSON_ASSERT (a.max == b.max);
+    BSON_ASSERT(a.min == b.min);
+    BSON_ASSERT(a.max == b.max);
 
-   if (!adjustBounds_u64 (&a.value,
-                          args.includeLowerBound,
-                          a.min,
-                          &b.value,
-                          args.includeUpperBound,
-                          b.max,
-                          status)) {
-      return NULL;
-   }
+    if (!adjustBounds_u64(&a.value, args.includeLowerBound, a.min, &b.value, args.includeUpperBound, b.max, status)) {
+        return NULL;
+    }
 
-   MinCoverGenerator_u64 *mcg = MinCoverGenerator_new_u64 (
-      a.value, b.value, a.max, args.sparsity, status);
-   if (!mcg) {
-      return NULL;
-   }
-   mc_mincover_t *mc = MinCoverGenerator_minCover_u64 (mcg);
-   MinCoverGenerator_destroy_u64 (mcg);
-   return mc;
+    MinCoverGenerator_u64 *mcg =
+        MinCoverGenerator_new_u64(a.value, b.value, a.max, args.sparsity, args.trimFactor, status, use_range_v2);
+    if (!mcg) {
+        return NULL;
+    }
+    mc_mincover_t *mc = MinCoverGenerator_minCover_u64(mcg);
+    mc->usedTrimFactor = MinCoverGenerator_usedTrimFactor_u64(mcg);
+    MinCoverGenerator_destroy_u64(mcg);
+    return mc;
 }
 
 // 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)
-{
-   BSON_ASSERT_PARAM (status);
-   CHECK_BOUNDS (args, "g", IDENTITY, LESSTHAN);
+mc_mincover_t *mc_getMincoverDouble(mc_getMincoverDouble_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+    BSON_ASSERT_PARAM(status);
+    CHECK_BOUNDS(args, "g", IDENTITY, LESSTHAN);
 
-   mc_OSTType_Double a, b;
-   if (!mc_getTypeInfoDouble (
-          (mc_getTypeInfoDouble_args_t){.value = args.lowerBound,
-                                        .min = args.min,
-                                        .max = args.max,
-                                        .precision = args.precision},
-          &a,
-          status)) {
-      return NULL;
-   }
-   if (!mc_getTypeInfoDouble (
-          (mc_getTypeInfoDouble_args_t){.value = args.upperBound,
-                                        .min = args.min,
-                                        .max = args.max,
-                                        .precision = args.precision},
-          &b,
-          status)) {
-      return NULL;
-   }
+    mc_OSTType_Double a, b;
+    if (!mc_getTypeInfoDouble((mc_getTypeInfoDouble_args_t){.value = args.lowerBound,
+                                                            .min = args.min,
+                                                            .max = args.max,
+                                                            .precision = args.precision},
+                              &a,
+                              status,
+                              use_range_v2)) {
+        return NULL;
+    }
+    if (!mc_getTypeInfoDouble((mc_getTypeInfoDouble_args_t){.value = args.upperBound,
+                                                            .min = args.min,
+                                                            .max = args.max,
+                                                            .precision = args.precision},
+                              &b,
+                              status,
+                              use_range_v2)) {
+        return NULL;
+    }
 
-   BSON_ASSERT (a.min == b.min);
-   BSON_ASSERT (a.max == b.max);
+    BSON_ASSERT(a.min == b.min);
+    BSON_ASSERT(a.max == b.max);
 
-   if (!adjustBounds_u64 (&a.value,
-                          args.includeLowerBound,
-                          a.min,
-                          &b.value,
-                          args.includeUpperBound,
-                          b.max,
-                          status)) {
-      return NULL;
-   }
+    if (!adjustBounds_u64(&a.value, args.includeLowerBound, a.min, &b.value, args.includeUpperBound, b.max, status)) {
+        return NULL;
+    }
 
-   MinCoverGenerator_u64 *mcg = MinCoverGenerator_new_u64 (
-      a.value, b.value, a.max, args.sparsity, status);
-   if (!mcg) {
-      return NULL;
-   }
-   mc_mincover_t *mc = MinCoverGenerator_minCover_u64 (mcg);
-   MinCoverGenerator_destroy_u64 (mcg);
-   return mc;
+    MinCoverGenerator_u64 *mcg =
+        MinCoverGenerator_new_u64(a.value, b.value, a.max, args.sparsity, args.trimFactor, status, use_range_v2);
+    if (!mcg) {
+        return NULL;
+    }
+    mc_mincover_t *mc = MinCoverGenerator_minCover_u64(mcg);
+    mc->usedTrimFactor = MinCoverGenerator_usedTrimFactor_u64(mcg);
+    MinCoverGenerator_destroy_u64(mcg);
+    return mc;
 }
 
 #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);
+mc_getMincoverDecimal128(mc_getMincoverDecimal128_args_t args, mongocrypt_status_t *status, bool use_range_v2) {
+    BSON_ASSERT_PARAM(status);
+#define ToString(Dec) (mc_dec128_to_string(Dec).str)
+    CHECK_BOUNDS(args, "s", ToString, mc_dec128_less);
 
-   mc_OSTType_Decimal128 a, b;
-   if (!mc_getTypeInfoDecimal128 (
-          (mc_getTypeInfoDecimal128_args_t){.value = args.lowerBound,
-                                            .min = args.min,
-                                            .max = args.max,
-                                            .precision = args.precision},
-          &a,
-          status)) {
-      return NULL;
-   }
-   if (!mc_getTypeInfoDecimal128 (
-          (mc_getTypeInfoDecimal128_args_t){.value = args.upperBound,
-                                            .min = args.min,
-                                            .max = args.max,
-                                            .precision = args.precision},
-          &b,
-          status)) {
-      return NULL;
-   }
+    mc_OSTType_Decimal128 a, b;
+    if (!mc_getTypeInfoDecimal128((mc_getTypeInfoDecimal128_args_t){.value = args.lowerBound,
+                                                                    .min = args.min,
+                                                                    .max = args.max,
+                                                                    .precision = args.precision},
+                                  &a,
+                                  status,
+                                  use_range_v2)) {
+        return NULL;
+    }
+    if (!mc_getTypeInfoDecimal128((mc_getTypeInfoDecimal128_args_t){.value = args.upperBound,
+                                                                    .min = args.min,
+                                                                    .max = args.max,
+                                                                    .precision = args.precision},
+                                  &b,
+                                  status,
+                                  use_range_v2)) {
+        return NULL;
+    }
 
-   BSON_ASSERT (mlib_int128_eq (a.min, b.min));
-   BSON_ASSERT (mlib_int128_eq (a.max, b.max));
+    BSON_ASSERT(mlib_int128_eq(a.min, b.min));
+    BSON_ASSERT(mlib_int128_eq(a.max, b.max));
 
-   if (!adjustBounds_u128 (&a.value,
-                           args.includeLowerBound,
-                           a.min,
-                           &b.value,
-                           args.includeUpperBound,
-                           b.max,
-                           status)) {
-      return NULL;
-   }
+    if (!adjustBounds_u128(&a.value, args.includeLowerBound, a.min, &b.value, args.includeUpperBound, b.max, status)) {
+        return NULL;
+    }
 
-   MinCoverGenerator_u128 *mcg = MinCoverGenerator_new_u128 (
-      a.value, b.value, a.max, args.sparsity, status);
-   if (!mcg) {
-      return NULL;
-   }
-   mc_mincover_t *mc = MinCoverGenerator_minCover_u128 (mcg);
-   MinCoverGenerator_destroy_u128 (mcg);
-   return mc;
+    MinCoverGenerator_u128 *mcg =
+        MinCoverGenerator_new_u128(a.value, b.value, a.max, args.sparsity, args.trimFactor, status, use_range_v2);
+    if (!mcg) {
+        return NULL;
+    }
+    mc_mincover_t *mc = MinCoverGenerator_minCover_u128(mcg);
+    mc->usedTrimFactor = MinCoverGenerator_usedTrimFactor_u128(mcg);
+    MinCoverGenerator_destroy_u128(mcg);
+    return mc;
 }
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT

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

@@ -23,18 +23,21 @@
 #include "mongocrypt-status-private.h"
 
 typedef struct {
-   bson_t *bson;
-   struct {
-      bson_iter_t value;
-      bool set;
-   } min;
-   struct {
-      bson_iter_t value;
-      bool set;
-   } max;
+    bson_t *bson;
 
-   int64_t sparsity;
-   mc_optional_uint32_t precision;
+    struct {
+        bson_iter_t value;
+        bool set;
+    } min;
+
+    struct {
+        bson_iter_t value;
+        bool set;
+    } max;
+
+    int64_t sparsity;
+    mc_optional_int32_t precision;
+    mc_optional_int32_t trimFactor;
 } mc_RangeOpts_t;
 
 /* mc_RangeOpts_parse parses a BSON document into mc_RangeOpts_t.
@@ -43,13 +46,11 @@ typedef struct {
  *    "min": BSON value,
  *    "max": BSON value,
  *    "sparsity": Int64,
- *    "precision": Optional<Int32>
+ *    "precision": Optional<Int32>,
+ *    "trimFactor": Optional<Int32>,
  * }
  */
-bool
-mc_RangeOpts_parse (mc_RangeOpts_t *ro,
-                    const bson_t *in,
-                    mongocrypt_status_t *status);
+bool mc_RangeOpts_parse(mc_RangeOpts_t *ro, const bson_t *in, bool use_range_v2, mongocrypt_status_t *status);
 
 /*
  * mc_RangeOpts_to_FLE2RangeInsertSpec creates a placeholder value to be
@@ -67,33 +68,40 @@ mc_RangeOpts_parse (mc_RangeOpts_t *ro,
  *
  * Preconditions: out must be initialized by caller.
  */
-bool
-mc_RangeOpts_to_FLE2RangeInsertSpec (const mc_RangeOpts_t *ro,
-                                     const bson_t *v,
-                                     bson_t *out,
-                                     mongocrypt_status_t *status);
+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
  * type. If `ro->min` is unset, uses the lowest representable value of the value
  * type. Errors if `valueType` does not match the type of `ro->min`. */
-bool
-mc_RangeOpts_appendMin (const mc_RangeOpts_t *ro,
-                        bson_type_t valueType,
-                        const char *fieldName,
-                        bson_t *out,
-                        mongocrypt_status_t *status);
+bool mc_RangeOpts_appendMin(const mc_RangeOpts_t *ro,
+                            bson_type_t valueType,
+                            const char *fieldName,
+                            bson_t *out,
+                            mongocrypt_status_t *status);
 
 /* mc_RangeOpts_appendMax appends the maximum value of the range for a given
  * type. If `ro->max` is unset, uses the highest representable value of the
  * value type. Errors if `valueType` does not match the type of `ro->max`. */
-bool
-mc_RangeOpts_appendMax (const mc_RangeOpts_t *ro,
-                        bson_type_t valueType,
-                        const char *fieldName,
-                        bson_t *out,
-                        mongocrypt_status_t *status);
+bool mc_RangeOpts_appendMax(const mc_RangeOpts_t *ro,
+                            bson_type_t valueType,
+                            const char *fieldName,
+                            bson_t *out,
+                            mongocrypt_status_t *status);
+
+/* mc_RangeOpts_appendTrimFactor appends the trim factor of the field. If `ro->trimFactor` is unset,
+ * defaults to 0. Errors if `ro->trimFactor` is out of bounds based on the size of the domain
+ * computed from `valueType`, `ro->min` and `ro->max`. */
+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);
 
-void
-mc_RangeOpts_cleanup (mc_RangeOpts_t *ro);
+void mc_RangeOpts_cleanup(mc_RangeOpts_t *ro);
 
 #endif // MC_RANGEOPTS_PRIVATE_H