chore: bump msrv version (#944)

gadomski · web-flow · commit 15c49ef9113c · 2026-02-02T09:56:54.000-07:00
Getting to dive into DuckDB query performance!
diff --git a/Cargo.toml b/Cargo.toml
@@ -30,7 +30,7 @@ homepage = "https://stac-utils.github.io/rustac"
 repository = "https://github.com/stac-utils/rustac"
 license = "MIT OR Apache-2.0"
 categories = ["science", "data-structures"]
-rust-version = "1.85"
+rust-version = "1.88"
 
 [workspace.dependencies]
 anyhow = "1.0"
diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs
@@ -458,7 +458,7 @@ impl Rustac {
                 load_collection_items,
                 create_collections,
             } => {
-                let bind = bind.as_deref().unwrap_or(&addr);
+                let bind = bind.as_deref().unwrap_or(addr);
                 if matches!(use_duckdb, Some(true))
                     || (use_duckdb.is_none() && hrefs.len() == 1 && hrefs[0].ends_with("parquet"))
                 {
diff --git a/crates/core/src/api/items.rs b/crates/core/src/api/items.rs
@@ -114,10 +114,10 @@ impl Items {
     /// let items = Items::default().valid().unwrap();
     /// ```
     pub fn valid(self) -> Result<Items> {
-        if let Some(bbox) = self.bbox.as_ref() {
-            if !bbox.is_valid() {
-                return Err(Error::InvalidBbox((*bbox).into(), "invalid bbox"));
-            }
+        if let Some(bbox) = self.bbox.as_ref()
+            && !bbox.is_valid()
+        {
+            return Err(Error::InvalidBbox((*bbox).into(), "invalid bbox"));
         }
         if let Some(datetime) = self.datetime.as_deref() {
             if let Some((start, end)) = datetime.split_once('/') {
@@ -126,10 +126,10 @@ impl Items {
                     maybe_parse_from_rfc3339(end)?,
                 );
                 if let Some(start) = start {
-                    if let Some(end) = end {
-                        if end < start {
-                            return Err(Error::StartIsAfterEnd(start, end));
-                        }
+                    if let Some(end) = end
+                        && end < start
+                    {
+                        return Err(Error::StartIsAfterEnd(start, end));
                     }
                 } else if end.is_none() {
                     return Err(Error::EmptyDatetimeInterval);
@@ -186,7 +186,7 @@ impl Items {
             #[cfg(feature = "geo")]
             {
                 let bbox: geo::Rect = (*bbox).into();
-                item.intersects(&bbox).map_err(Error::from)
+                item.intersects(&bbox)
             }
             #[cfg(not(feature = "geo"))]
             {
@@ -215,7 +215,7 @@ impl Items {
     /// ```
     pub fn datetime_matches(&self, item: &Item) -> Result<bool> {
         if let Some(datetime) = self.datetime.as_ref() {
-            item.intersects_datetime_str(datetime).map_err(Error::from)
+            item.intersects_datetime_str(datetime)
         } else {
             Ok(true)
         }
diff --git a/crates/core/src/api/search.rs b/crates/core/src/api/search.rs
@@ -239,7 +239,7 @@ impl Search {
                 #[cfg(feature = "geo")]
                 {
                     let intersects: geo::Geometry = intersects.try_into().map_err(Box::new)?;
-                    item.intersects(&intersects).map_err(Error::from)
+                    item.intersects(&intersects)
                 }
                 #[cfg(not(feature = "geo"))]
                 {
@@ -363,26 +363,25 @@ fn expand_datetime_to_start(s: &str) -> Result<DateTime<FixedOffset>> {
     let midnight = NaiveTime::from_hms_opt(0, 0, 0).expect("midnight (0, 0, 0) is always valid");
 
     // Case 1: Year only (e.g., "2023") -> 2023-01-01T00:00:00Z
-    if trimmed.len() == 4 && trimmed.chars().all(|c| c.is_numeric()) {
-        if let Ok(year) = trimmed.parse::<i32>() {
-            let date = NaiveDate::from_ymd_opt(year, 1, 1).ok_or(Error::InvalidYear(year))?;
-            let datetime = date.and_time(midnight);
-            return Ok(Utc.from_utc_datetime(&datetime).fixed_offset());
-        }
+    if trimmed.len() == 4
+        && trimmed.chars().all(|c| c.is_numeric())
+        && let Ok(year) = trimmed.parse::<i32>()
+    {
+        let date = NaiveDate::from_ymd_opt(year, 1, 1).ok_or(Error::InvalidYear(year))?;
+        let datetime = date.and_time(midnight);
+        return Ok(Utc.from_utc_datetime(&datetime).fixed_offset());
     }
 
     // Case 2: Year-Month (e.g., "2023-01") -> 2023-01-01T00:00:00Z
-    if trimmed.len() == 7 && trimmed.chars().nth(4) == Some('-') {
-        if let Some((year_str, month_str)) = trimmed.split_once('-') {
-            if let (Ok(year), Ok(month)) = (year_str.parse::<i32>(), month_str.parse::<u32>()) {
-                if (1..=12).contains(&month) {
-                    let date =
-                        NaiveDate::from_ymd_opt(year, month, 1).ok_or(Error::InvalidYear(year))?;
-                    let datetime = date.and_time(midnight);
-                    return Ok(Utc.from_utc_datetime(&datetime).fixed_offset());
-                }
-            }
-        }
+    if trimmed.len() == 7
+        && trimmed.chars().nth(4) == Some('-')
+        && let Some((year_str, month_str)) = trimmed.split_once('-')
+        && let (Ok(year), Ok(month)) = (year_str.parse::<i32>(), month_str.parse::<u32>())
+        && (1..=12).contains(&month)
+    {
+        let date = NaiveDate::from_ymd_opt(year, month, 1).ok_or(Error::InvalidYear(year))?;
+        let datetime = date.and_time(midnight);
+        return Ok(Utc.from_utc_datetime(&datetime).fixed_offset());
     }
 
     // Case 3: ISO 8601 date (e.g., "2023-06-15") -> 2023-06-15T00:00:00Z
@@ -400,34 +399,34 @@ fn expand_datetime_to_end(s: &str) -> Result<DateTime<FixedOffset>> {
     let end_of_day = NaiveTime::from_hms_opt(23, 59, 59).expect("23:59:59 is always valid");
 
     // Case 1: Year only (e.g., "2023") -> 2023-12-31T23:59:59Z
-    if trimmed.len() == 4 && trimmed.chars().all(|c| c.is_numeric()) {
-        if let Ok(year) = trimmed.parse::<i32>() {
-            let date = NaiveDate::from_ymd_opt(year, 12, 31).ok_or(Error::InvalidYear(year))?;
-            let datetime = date.and_time(end_of_day);
-            return Ok(Utc.from_utc_datetime(&datetime).fixed_offset());
-        }
+    if trimmed.len() == 4
+        && trimmed.chars().all(|c| c.is_numeric())
+        && let Ok(year) = trimmed.parse::<i32>()
+    {
+        let date = NaiveDate::from_ymd_opt(year, 12, 31).ok_or(Error::InvalidYear(year))?;
+        let datetime = date.and_time(end_of_day);
+        return Ok(Utc.from_utc_datetime(&datetime).fixed_offset());
     }
 
     // Case 2: Year-Month (e.g., "2023-01") -> 2023-01-31T23:59:59Z (last day of month)
-    if trimmed.len() == 7 && trimmed.chars().nth(4) == Some('-') {
-        if let Some((year_str, month_str)) = trimmed.split_once('-') {
-            if let (Ok(year), Ok(month)) = (year_str.parse::<i32>(), month_str.parse::<u32>()) {
-                if (1..=12).contains(&month) {
-                    // Get the last day of the month by going to first day of next month, then back one day
-                    let last_day = if month == 12 {
-                        NaiveDate::from_ymd_opt(year + 1, 1, 1)
-                    } else {
-                        NaiveDate::from_ymd_opt(year, month + 1, 1)
-                    }
-                    .ok_or(Error::InvalidYear(year))?
-                    .pred_opt()
-                    .ok_or(Error::InvalidYear(year))?;
-
-                    let datetime = last_day.and_time(end_of_day);
-                    return Ok(Utc.from_utc_datetime(&datetime).fixed_offset());
-                }
-            }
+    if trimmed.len() == 7
+        && trimmed.chars().nth(4) == Some('-')
+        && let Some((year_str, month_str)) = trimmed.split_once('-')
+        && let (Ok(year), Ok(month)) = (year_str.parse::<i32>(), month_str.parse::<u32>())
+        && (1..=12).contains(&month)
+    {
+        // Get the last day of the month by going to first day of next month, then back one day
+        let last_day = if month == 12 {
+            NaiveDate::from_ymd_opt(year + 1, 1, 1)
+        } else {
+            NaiveDate::from_ymd_opt(year, month + 1, 1)
         }
+        .ok_or(Error::InvalidYear(year))?
+        .pred_opt()
+        .ok_or(Error::InvalidYear(year))?;
+
+        let datetime = last_day.and_time(end_of_day);
+        return Ok(Utc.from_utc_datetime(&datetime).fixed_offset());
     }
 
     // Case 3: ISO 8601 date (e.g., "2023-06-15") -> 2023-06-15T23:59:59Z
diff --git a/crates/core/src/collection.rs b/crates/core/src/collection.rs
@@ -360,15 +360,15 @@ impl TemporalExtent {
         if self.interval.is_empty() {
             self.interval.push([start, end]);
         } else {
-            if let Some(start) = start {
-                if self.interval[0][0].map(|dt| dt > start).unwrap_or(true) {
-                    self.interval[0][0] = Some(start);
-                }
+            if let Some(start) = start
+                && self.interval[0][0].map(|dt| dt > start).unwrap_or(true)
+            {
+                self.interval[0][0] = Some(start);
             }
-            if let Some(end) = end {
-                if self.interval[0][1].map(|dt| dt < end).unwrap_or(true) {
-                    self.interval[0][1] = Some(end);
-                }
+            if let Some(end) = end
+                && self.interval[0][1].map(|dt| dt < end).unwrap_or(true)
+            {
+                self.interval[0][1] = Some(end);
             }
         }
     }
diff --git a/crates/core/src/geoparquet.rs b/crates/core/src/geoparquet.rs
@@ -456,12 +456,13 @@ impl WriterState {
     /// assert_eq!(metadata[1].key, "stac-geoparquet");
     /// ```
     pub fn into_metadata(self) -> Result<Vec<KeyValue>> {
-        let mut metadata = Vec::with_capacity(2);
-        metadata.push(self.encoder.into_keyvalue()?);
-        metadata.push(KeyValue::new(
-            METADATA_KEY.to_string(),
-            serde_json::to_string(&self.metadata)?,
-        ));
+        let metadata = vec![
+            self.encoder.into_keyvalue()?,
+            KeyValue::new(
+                METADATA_KEY.to_string(),
+                serde_json::to_string(&self.metadata)?,
+            ),
+        ];
         Ok(metadata)
     }
 }
diff --git a/crates/core/src/item.rs b/crates/core/src/item.rs
@@ -528,19 +528,17 @@ impl Item {
     ) -> Result<bool> {
         let (item_start, item_end) = self.datetimes();
         let mut intersects = true;
-        if let Some(start) = start {
-            if let Some(item_end) = item_end {
-                if item_end < start {
-                    intersects = false;
-                }
-            }
+        if let Some(start) = start
+            && let Some(item_end) = item_end
+            && item_end < start
+        {
+            intersects = false;
         }
-        if let Some(end) = end {
-            if let Some(item_start) = item_start {
-                if item_start > end {
-                    intersects = false;
-                }
-            }
+        if let Some(end) = end
+            && let Some(item_start) = item_start
+            && item_start > end
+        {
+            intersects = false;
         }
         Ok(intersects)
     }
diff --git a/crates/core/src/migrate.rs b/crates/core/src/migrate.rs
@@ -166,17 +166,17 @@ fn migrate_bands(asset: &mut Map<String, Value>) -> Result<()> {
         }
     }
     for (key, count) in counts {
-        if let Some((value_as_string, &count)) = count.iter().max_by_key(|&(_, &count)| count) {
-            if count > 1 {
-                let value = values
-                    .get(value_as_string)
-                    .expect("every value should be in the lookup hash")
-                    .clone();
-                for band in &mut bands {
-                    if band.get(&key).map(|v| v == &value).unwrap_or_default() {
-                        let value = band.remove(&key).unwrap();
-                        let _ = asset.insert(key.clone(), value);
-                    }
+        if let Some((value_as_string, &count)) = count.iter().max_by_key(|&(_, &count)| count)
+            && count > 1
+        {
+            let value = values
+                .get(value_as_string)
+                .expect("every value should be in the lookup hash")
+                .clone();
+            for band in &mut bands {
+                if band.get(&key).map(|v| v == &value).unwrap_or_default() {
+                    let value = band.remove(&key).unwrap();
+                    let _ = asset.insert(key.clone(), value);
                 }
             }
         }
@@ -193,20 +193,16 @@ fn migrate_bands(asset: &mut Map<String, Value>) -> Result<()> {
 fn migrate_links(object: &mut Map<String, Value>) {
     if let Some(links) = object.get_mut("links").and_then(|v| v.as_array_mut()) {
         for link in links {
-            if let Some(link) = link.as_object_mut() {
-                if link
+            if let Some(link) = link.as_object_mut()
+                && link
                     .get("rel")
                     .and_then(|v| v.as_str())
                     .map(|s| s == "self")
                     .unwrap_or_default()
-                {
-                    if let Some(href) = link.get("href").and_then(|v| v.as_str()) {
-                        if href.starts_with('/') {
-                            let _ =
-                                link.insert("href".to_string(), format!("file://{href}").into());
-                        }
-                    }
-                }
+                && let Some(href) = link.get("href").and_then(|v| v.as_str())
+                && href.starts_with('/')
+            {
+                let _ = link.insert("href".to_string(), format!("file://{href}").into());
             }
         }
     }
diff --git a/crates/duckdb/src/client.rs b/crates/duckdb/src/client.rs
@@ -234,6 +234,7 @@ impl Client {
             log::debug!("duckdb sql: {sql}");
             let mut statement = self.prepare(&sql)?;
             statement.execute(duckdb::params_from_iter(params))?;
+            log::debug!("query complete");
             Ok(SearchArrowBatchIter::new(
                 statement,
                 self.convert_wkb,
@@ -284,12 +285,11 @@ impl Client {
                 has_end_datetime = true;
             }
 
-            if let Some(fields) = search.fields.as_ref() {
-                if fields.exclude.contains(&column)
-                    || !(fields.include.is_empty() || fields.include.contains(&column))
-                {
-                    continue;
-                }
+            if let Some(fields) = search.fields.as_ref()
+                && (fields.exclude.contains(&column)
+                    || !(fields.include.is_empty() || fields.include.contains(&column)))
+            {
+                continue;
             }
 
             if column == "geometry" {
diff --git a/crates/io/src/api.rs b/crates/io/src/api.rs
@@ -25,10 +25,10 @@ pub async fn search(
     max_items: Option<usize>,
 ) -> Result<ItemCollection> {
     let client = Client::new(href)?;
-    if search.limit.is_none() {
-        if let Some(max_items) = max_items {
-            search.limit = Some(max_items.try_into()?);
-        }
+    if search.limit.is_none()
+        && let Some(max_items) = max_items
+    {
+        search.limit = Some(max_items.try_into()?);
     }
     let stream = client.search(search).await?;
     let mut items = if let Some(max_items) = max_items {
@@ -43,10 +43,10 @@ pub async fn search(
     while let Some(item) = stream.next().await {
         let item = item?;
         items.push(item);
-        if let Some(max_items) = max_items {
-            if items.len() >= max_items {
-                break;
-            }
+        if let Some(max_items) = max_items
+            && items.len() >= max_items
+        {
+            break;
         }
     }
     let item_collection = ItemCollection::new(items)?;
@@ -394,14 +394,13 @@ fn stream_pages(
 
 fn not_found_to_none<T>(result: Result<T>) -> Result<Option<T>> {
     let mut result = result.map(Some);
-    if let Err(Error::Reqwest(ref err)) = result {
-        if err
+    if let Err(Error::Reqwest(ref err)) = result
+        && err
             .status()
             .map(|s| s == StatusCode::NOT_FOUND)
             .unwrap_or_default()
-        {
-            result = Ok(None);
-        }
+    {
+        result = Ok(None);
     }
     result
 }
diff --git a/crates/server/src/api.rs b/crates/server/src/api.rs

Original file line number	Diff line number	Diff line change
`@@ -458,7 +458,7 @@ impl Rustac {`
`458`	`458`	`load_collection_items,`
`459`	`459`	`create_collections,`
`460`	`460`	`} => {`
`461`		`- let bind = bind.as_deref().unwrap_or(&addr);`
	`461`	`+ let bind = bind.as_deref().unwrap_or(addr);`
`462`	`462`	`if matches!(use_duckdb, Some(true))`
`463`	`463`	`\|\| (use_duckdb.is_none() && hrefs.len() == 1 && hrefs[0].ends_with("parquet"))`
`464`	`464`	`{`
Original file line number	Diff line number	Diff line change
`@@ -360,15 +360,15 @@ impl TemporalExtent {`
`360`	`360`	`if self.interval.is_empty() {`
`361`	`361`	`self.interval.push([start, end]);`
`362`	`362`	`} else {`
`363`		`- if let Some(start) = start {`
`364`		`- if self.interval[0][0].map(\|dt\| dt > start).unwrap_or(true) {`
`365`		`- self.interval[0][0] = Some(start);`
`366`		`- }`
	`363`	`+ if let Some(start) = start`
	`364`	`+ && self.interval[0][0].map(\|dt\| dt > start).unwrap_or(true)`
	`365`	`+ {`
	`366`	`+ self.interval[0][0] = Some(start);`
`367`	`367`	`}`
`368`		`- if let Some(end) = end {`
`369`		`- if self.interval[0][1].map(\|dt\| dt < end).unwrap_or(true) {`
`370`		`- self.interval[0][1] = Some(end);`
`371`		`- }`
	`368`	`+ if let Some(end) = end`
	`369`	`+ && self.interval[0][1].map(\|dt\| dt < end).unwrap_or(true)`
	`370`	`+ {`
	`371`	`+ self.interval[0][1] = Some(end);`
`372`	`372`	`}`
`373`	`373`	`}`
`374`	`374`	`}`