Clamp zero connection count

Author: ryanfowler

src/pool.rs

@@ -37,7 +37,7 @@ pub struct PoolBuilder {
     flags: OpenFlags,
     journal_mode: Option<JournalMode>,
     vfs: Option<String>,
-    num_conns: Option<NonZeroUsize>,
+    num_conns: Option<usize>,
 }
 
 impl PoolBuilder {
@@ -78,22 +78,16 @@ impl PoolBuilder {
 
     /// Specify the number of sqlite connections to open as part of the pool.
     ///
-    /// Defaults to the number of logical CPUs of the current system.
+    /// Defaults to the number of logical CPUs of the current system. Values
+    /// less than `1` are clamped to `1`.
     ///
     /// ```
     /// use async_sqlite::PoolBuilder;
-    /// use std::num::NonZeroUsize;
     ///
-    /// let builder = PoolBuilder::new().num_conns(NonZeroUsize::new(2).unwrap());
+    /// let builder = PoolBuilder::new().num_conns(2);
     /// ```
-    ///
-    /// ```compile_fail
-    /// use async_sqlite::PoolBuilder;
-    ///
-    /// PoolBuilder::new().num_conns(0);
-    /// ```
-    pub fn num_conns(mut self, num_conns: NonZeroUsize) -> Self {
-        self.num_conns = Some(num_conns);
+    pub fn num_conns(mut self, num_conns: usize) -> Self {
+        self.num_conns = Some(num_conns.max(1));
         self
     }
 
@@ -110,7 +104,7 @@ impl PoolBuilder {
     /// ```
     pub async fn open(self) -> Result<Pool, Error> {
         let num_conns = self.get_num_conns();
-        let opens = (0..num_conns.get()).map(|_| {
+        let opens = (0..num_conns).map(|_| {
             ClientBuilder {
                 path: self.path.clone(),
                 flags: self.flags,
@@ -145,7 +139,7 @@ impl PoolBuilder {
     /// ```
     pub fn open_blocking(self) -> Result<Pool, Error> {
         let num_conns = self.get_num_conns();
-        let clients = (0..num_conns.get())
+        let clients = (0..num_conns)
             .map(|_| {
                 ClientBuilder {
                     path: self.path.clone(),
@@ -164,8 +158,8 @@ impl PoolBuilder {
         })
     }
 
-    fn get_num_conns(&self) -> NonZeroUsize {
-        self.num_conns.unwrap_or_else(|| {
+    fn get_num_conns(&self) -> usize {
+            .unwrap_or_else(|| available_parallelism().unwrap_or_else(|_| NonZeroUsize::new(1).unwrap()).into())
             available_parallelism().unwrap_or_else(|_| NonZeroUsize::new(1).unwrap())
         })
     }

tests/tests.rs

@@ -1,5 +1,4 @@
 use async_sqlite::{ClientBuilder, Error, JournalMode, PoolBuilder};
-use std::num::NonZeroUsize;
 
 #[test]
 fn test_blocking_client() {
@@ -85,6 +84,7 @@ async_test!(test_journal_mode);
 async_test!(test_concurrency);
 async_test!(test_pool);
 async_test!(test_pool_conn_for_each);
+async_test!(test_pool_num_conns_zero_clamps);
 
 async fn test_journal_mode() {
     let tmp_dir = tempfile::tempdir().unwrap();
@@ -139,7 +139,7 @@ async fn test_pool() {
     let tmp_dir = tempfile::tempdir().unwrap();
     let pool = PoolBuilder::new()
         .path(tmp_dir.path().join("sqlite.db"))
-        .num_conns(NonZeroUsize::new(2).unwrap())
+        .num_conns(2)
         .open()
         .await
         .expect("client unable to be opened");
@@ -192,7 +192,7 @@ async fn test_pool_conn_for_each() {
 
     let pool = PoolBuilder::new()
         .path(tmp_dir.path().join("another-sqlite.db"))
-        .num_conns(NonZeroUsize::new(2).unwrap())
+        .num_conns(2)
         .open()
         .await
         .expect("pool unable to be opened");
@@ -228,3 +228,15 @@ async fn test_pool_conn_for_each() {
     // cleanup
     pool.close().await.expect("closing client conn");
 }
+
+async fn test_pool_num_conns_zero_clamps() {
+    let tmp_dir = tempfile::tempdir().unwrap();
+    let pool = PoolBuilder::new()
+        .path(tmp_dir.path().join("clamp.db"))
+        .num_conns(0)
+        .open()
+        .await
+        .expect("pool unable to be opened");
+    let results = pool.conn_for_each(|_| Ok(())).await;
+    assert_eq!(results.len(), 1);
+}