RUST-764 Use unsigned integers for values that should always be non-negative (#333)

Author: patrickfreed

src/bson_util/mod.rs

@@ -108,14 +108,13 @@ where
 }
 
 #[allow(clippy::trivially_copy_pass_by_ref)]
-pub(crate) fn serialize_u32_as_i32<S: Serializer>(
+pub(crate) fn serialize_u32_option_as_i32<S: Serializer>(
     val: &Option<u32>,
     serializer: S,
 ) -> std::result::Result<S::Ok, S::Error> {
     match val {
-        Some(val) if { *val <= std::i32::MAX as u32 } => serializer.serialize_i32(*val as i32),
+        Some(ref val) => bson::serde_helpers::serialize_u32_as_i32(val, serializer),
         None => serializer.serialize_none(),
-        _ => Err(ser::Error::custom("u32 specified does not fit into an i32")),
     }
 }
 
@@ -136,6 +135,16 @@ pub(crate) fn serialize_batch_size<S: Serializer>(
     }
 }
 
+pub(crate) fn serialize_u64_option_as_i64<S: Serializer>(
+    val: &Option<u64>,
+    serializer: S,
+) -> std::result::Result<S::Ok, S::Error> {
+    match val {
+        Some(ref v) => bson::serde_helpers::serialize_u64_as_i64(v, serializer),
+        None => serializer.serialize_none(),
+    }
+}
+
 /// Deserialize an u64 from any BSON number type if it could be done losslessly.
 pub(crate) fn deserialize_u64_from_bson_number<'de, D>(
     deserializer: D,

src/client/options/mod.rs

@@ -5,6 +5,7 @@ mod resolver_config;
 
 use std::{
     collections::HashSet,
+    convert::TryFrom,
     fmt::{self, Display, Formatter},
     fs::File,
     hash::{Hash, Hasher},
@@ -1654,18 +1655,17 @@ impl ClientOptionsParser {
                 let mut write_concern = self.write_concern.get_or_insert_with(Default::default);
 
                 match i32::from_str_radix(value, 10) {
-                    Ok(w) => {
-                        if w < 0 {
+                    Ok(w) => match u32::try_from(w) {
+                        Ok(uw) => write_concern.w = Some(Acknowledgment::from(uw)),
+                        Err(_) => {
                             return Err(ErrorKind::ArgumentError {
                                 message: "connection string `w` option cannot be a negative \
                                           integer"
                                     .to_string(),
                             }
-                            .into());
+                            .into())
                         }
-
-                        write_concern.w = Some(Acknowledgment::from(w));
-                    }
+                    },
                     Err(_) => {
                         write_concern.w = Some(Acknowledgment::from(value.to_string()));
                     }

src/coll/mod.rs

@@ -260,7 +260,7 @@ where
     pub async fn estimated_document_count(
         &self,
         options: impl Into<Option<EstimatedDocumentCountOptions>>,
-    ) -> Result<i64> {
+    ) -> Result<u64> {
         let mut options = options.into();
         resolve_options!(self, options, [read_concern, selection_criteria]);
 
@@ -274,7 +274,7 @@ where
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<CountOptions>>,
         session: impl Into<Option<&mut ClientSession>>,
-    ) -> Result<i64> {
+    ) -> Result<u64> {
         let mut options = options.into();
         resolve_options!(self, options, [read_concern, selection_criteria]);
 
@@ -290,7 +290,7 @@ where
         &self,
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<CountOptions>>,
-    ) -> Result<i64> {
+    ) -> Result<u64> {
         self.count_documents_common(filter, options, None).await
     }
 
@@ -303,7 +303,7 @@ where
         filter: impl Into<Option<Document>>,
         options: impl Into<Option<CountOptions>>,
         session: &mut ClientSession,
-    ) -> Result<i64> {
+    ) -> Result<u64> {
         self.count_documents_common(filter, options, session).await
     }
 

src/coll/options.rs

@@ -10,7 +10,8 @@ use crate::{
         deserialize_duration_from_u64_millis,
         serialize_batch_size,
         serialize_duration_as_int_millis,
-        serialize_u32_as_i32,
+        serialize_u32_option_as_i32,
+        serialize_u64_option_as_i64,
     },
     concern::{ReadConcern, WriteConcern},
     options::Collation,
@@ -498,7 +499,7 @@ pub struct CountOptions {
     pub hint: Option<Hint>,
 
     /// The maximum number of documents to count.
-    pub limit: Option<i64>,
+    pub limit: Option<u64>,
 
     /// The maximum amount of time to allow the query to run.
     ///
@@ -508,7 +509,7 @@ pub struct CountOptions {
     pub max_time: Option<Duration>,
 
     /// The number of documents to skip before counting.
-    pub skip: Option<i64>,
+    pub skip: Option<u64>,
 
     /// The collation to use for the operation.
     ///
@@ -519,7 +520,6 @@ pub struct CountOptions {
     /// The criteria used to select a server for this operation.
     ///
     /// If none specified, the default set on the collection will be used.
-    #[serde(skip_serializing)]
     pub selection_criteria: Option<SelectionCriteria>,
 
     /// The level of the read concern.
@@ -618,7 +618,7 @@ pub struct FindOptions {
     /// only the number of documents kept in memory at a given time (and by extension, the
     /// number of round trips needed to return the entire set of documents returned by the
     /// query.
-    #[serde(serialize_with = "serialize_u32_as_i32")]
+    #[serde(serialize_with = "serialize_u32_option_as_i32")]
     pub batch_size: Option<u32>,
 
     /// Tags the query with an arbitrary string to help trace the operation through the database
@@ -650,7 +650,8 @@ pub struct FindOptions {
     ///
     /// Note: this option is deprecated starting in MongoDB version 4.0 and removed in MongoDB 4.2.
     /// Use the maxTimeMS option instead.
-    pub max_scan: Option<i64>,
+    #[serde(serialize_with = "serialize_u64_option_as_i64")]
+    pub max_scan: Option<u64>,
 
     /// The maximum amount of time to allow the query to run.
     ///
@@ -689,7 +690,8 @@ pub struct FindOptions {
     pub show_record_id: Option<bool>,
 
     /// The number of documents to skip before counting.
-    pub skip: Option<i64>,
+    #[serde(serialize_with = "serialize_u64_option_as_i64")]
+    pub skip: Option<u64>,
 
     /// The order of the documents for the purposes of the operation.
     pub sort: Option<Document>,
@@ -774,7 +776,8 @@ pub struct FindOneOptions {
     ///
     /// Note: this option is deprecated starting in MongoDB version 4.0 and removed in MongoDB 4.2.
     /// Use the maxTimeMS option instead.
-    pub max_scan: Option<i64>,
+    #[serde(serialize_with = "serialize_u64_option_as_i64")]
+    pub max_scan: Option<u64>,
 
     /// The maximum amount of time to allow the query to run.
     ///
@@ -806,7 +809,8 @@ pub struct FindOneOptions {
     pub show_record_id: Option<bool>,
 
     /// The number of documents to skip before counting.
-    pub skip: Option<i64>,
+    #[serde(serialize_with = "serialize_u64_option_as_i64")]
+    pub skip: Option<u64>,
 
     /// The order of the documents for the purposes of the operation.
     pub sort: Option<Document>,

src/concern/mod.rs

@@ -10,7 +10,7 @@ use serde_with::skip_serializing_none;
 use typed_builder::TypedBuilder;
 
 use crate::{
-    bson::doc,
+    bson::{doc, serde_helpers},
     bson_util,
     error::{ErrorKind, Result},
 };
@@ -169,9 +169,11 @@ pub enum Acknowledgment {
     /// the driver will not receive a response indicating whether an operation succeeded or failed.
     /// It also means that the operation cannot be associated with a session. It is reccommended to
     /// avoid using unacknowledged write concerns.
-    Nodes(i32),
+    Nodes(u32),
+
     /// Requires acknowledgement that the write has reached the majority of nodes.
     Majority,
+
     /// Requires acknowledgement according to the given custom write concern. See [here](https://docs.mongodb.com/manual/tutorial/configure-replica-set-tag-sets/#tag-sets-and-custom-write-concern-behavior)
     /// for more information.
     Custom(String),
@@ -184,7 +186,7 @@ impl Serialize for Acknowledgment {
     {
         match self {
             Acknowledgment::Majority => serializer.serialize_str("majority"),
-            Acknowledgment::Nodes(n) => serializer.serialize_i32(*n),
+            Acknowledgment::Nodes(n) => serde_helpers::serialize_u32_as_i32(n, serializer),
             Acknowledgment::Custom(name) => serializer.serialize_str(name),
         }
     }
@@ -198,7 +200,7 @@ impl<'de> Deserialize<'de> for Acknowledgment {
         #[derive(Deserialize)]
         #[serde(untagged)]
         enum IntOrString {
-            Int(i32),
+            Int(u32),
             String(String),
         }
         match IntOrString::deserialize(deserializer)? {
@@ -208,8 +210,8 @@ impl<'de> Deserialize<'de> for Acknowledgment {
     }
 }
 
-impl From<i32> for Acknowledgment {
-    fn from(i: i32) -> Self {
+impl From<u32> for Acknowledgment {
+    fn from(i: u32) -> Self {
         Acknowledgment::Nodes(i)
     }
 }
@@ -231,7 +233,7 @@ impl Acknowledgment {
     #[cfg(all(test, not(feature = "sync")))]
     pub(crate) fn to_bson(&self) -> Bson {
         match self {
-            Acknowledgment::Nodes(i) => Bson::Int32(*i),
+            Acknowledgment::Nodes(i) => Bson::Int32(*i as i32),
             Acknowledgment::Majority => Bson::String("majority".to_string()),
             Acknowledgment::Custom(s) => Bson::String(s.to_string()),
         }
@@ -244,18 +246,9 @@ impl WriteConcern {
         self.w != Some(Acknowledgment::Nodes(0)) || self.journal == Some(true)
     }
 
-    /// Validates that the write concern. A write concern is invalid if the `w` field is 0
+    /// Validates that the write concern. A write concern is invalid if both the `w` field is 0
     /// and the `j` field is `true`.
-    pub fn validate(&self) -> Result<()> {
-        if let Some(Acknowledgment::Nodes(i)) = self.w {
-            if i < 0 {
-                return Err(ErrorKind::ArgumentError {
-                    message: "write concern `w` field cannot be negative integer".to_string(),
-                }
-                .into());
-            }
-        }
-
+    pub(crate) fn validate(&self) -> Result<()> {
         if self.w == Some(Acknowledgment::Nodes(0)) && self.journal == Some(true) {
             return Err(ErrorKind::ArgumentError {
                 message: "write concern cannot have w=0 and j=true".to_string(),

src/db/options.rs

@@ -39,12 +39,14 @@ pub struct CreateCollectionOptions {
 
     /// The maximum size (in bytes) for a capped collection. This option is ignored if `capped` is
     /// not set to true.
-    pub size: Option<i64>,
+    #[serde(serialize_with = "bson_util::serialize_u64_option_as_i64")]
+    pub size: Option<u64>,
 
     /// The maximum number of documents in a capped collection. The `size` limit takes precedence
     /// over this option. If a capped collection reaches the size limit before it reaches the
     /// maximum number of documents, MongoDB removes old documents.
-    pub max: Option<i64>,
+    #[serde(serialize_with = "bson_util::serialize_u64_option_as_i64")]
+    pub max: Option<u64>,
 
     /// The storage engine that the collection should use. The value should take the following
     /// form:

src/operation/count/mod.rs

@@ -37,7 +37,7 @@ impl Count {
 }
 
 impl Operation for Count {
-    type O = i64;
+    type O = u64;
     const NAME: &'static str = "count";
 
     fn build(&self, description: &StreamDescription) -> Result<Command> {
@@ -122,5 +122,5 @@ impl Operation for Count {
 
 #[derive(Debug, Deserialize)]
 struct ResponseBody {
-    n: i64,
+    n: u64,
 }

src/operation/count_documents/mod.rs

@@ -64,7 +64,7 @@ impl CountDocuments {
 }
 
 impl Operation for CountDocuments {
-    type O = i64;
+    type O = u64;
     const NAME: &'static str = Aggregate::NAME;
 
     fn build(&self, description: &StreamDescription) -> Result<Command> {
@@ -98,7 +98,7 @@ impl Operation for CountDocuments {
             }
         };
 
-        bson_util::get_int(n).ok_or_else(|| {
+        bson_util::get_u64(n).ok_or_else(|| {
             ErrorKind::ResponseError {
                 message: format!(
                     "server response to count_documents aggregate should have contained integer \

src/operation/mod.rs

@@ -155,7 +155,7 @@ struct WriteResponseBody<T = EmptyBody> {
     #[serde(flatten)]
     body: T,
 
-    n: i64,
+    n: u64,
 
     #[serde(rename = "writeErrors")]
     write_errors: Option<Vec<BulkWriteError>>,

src/operation/update/mod.rs

@@ -152,6 +152,6 @@ impl Operation for Update {
 #[derive(Deserialize)]
 struct UpdateBody {
     #[serde(rename = "nModified")]
-    n_modified: i64,
+    n_modified: u64,
     upserted: Option<Vec<Document>>,
 }