feat(rust/sedona-raster): trinary Override for BandOverrides; copy_into stops composing views

Replace the all-Option BandOverrides fields with a trinary Override<T>
(Keep/Clear/Set) for the clearable fields (name, nodata, outdb_uri,
outdb_format, view); dim_names stays Option because a band always has dim
names, so there is no absent state for Clear to express. copy_into now
resolves each field by matching on the Override and never composes the
view: Keep inherits the source view, Clear resets to the canonical
identity view, and Set uses the given view verbatim. Callers that want
the old compose behaviour pass Set(&source.view().compose(&next)?).

RasterBuilder::with_view adopts this model: it composes the supplied
delta onto the input's own view itself and passes the absolute result as
Override::Set, inheriting nodata and the outdb hints from the input via
Override::Keep (a None override maps to Keep, an explicit value to Set).
This keeps both the source-nodata inheritance and the compose-time bound
against the parent's visible window that copy_into used to provide.

Author: james-willis

rust/sedona-raster/src/array.rs

@@ -819,7 +819,7 @@ impl<'a> RasterStructArray<'a> {
 mod tests {
     use super::*;
     use crate::builder::{RasterBuilder, StartBandArgs};
-    use crate::traits::BandOverrides;
+    use crate::traits::{BandOverrides, Override};
     use arrow_array::{ArrayRef, ListArray, StructArray, UInt32Array};
     use arrow_buffer::{NullBuffer, OffsetBuffer, ScalarBuffer};
     use arrow_schema::{DataType, Field, Fields};
@@ -888,7 +888,7 @@ mod tests {
             .copy_into(
                 &mut ob,
                 BandOverrides {
-                    name: Some("derived"),
+                    name: Override::Set("derived"),
                     ..Default::default()
                 },
             )
@@ -918,9 +918,9 @@ mod tests {
 
     #[test]
     fn copy_into_with_identity_override_view_succeeds() {
-        // An explicit identity override composes back to the identity, so it is
-        // accepted and behaves exactly like the inherited (None) case — this
-        // exercises the new `BandOverrides::view` path end to end.
+        // An explicit identity `Set` override is the identity view, so it is
+        // accepted and behaves exactly like the inherited (`Keep`) case — this
+        // exercises the `BandOverrides::view` `Set` path end to end.
         let transform = [0.0, 1.0, 0.0, 0.0, 0.0, -1.0];
         let mut ib = RasterBuilder::new(1);
         ib.start_raster_nd(&transform, &["x"], &[4], None).unwrap();
@@ -949,7 +949,7 @@ mod tests {
             .copy_into(
                 &mut ob,
                 BandOverrides {
-                    view: Some(&identity),
+                    view: Override::Set(&identity),
                     ..Default::default()
                 },
             )

rust/sedona-raster/src/builder.rs

@@ -27,8 +27,8 @@ use sedona_schema::raster::{BandDataType, RasterSchema};
 
 use crate::band_builder::{BandArrayBuilder, BandWriter};
 use crate::error::RasterError;
-use crate::traits::{BandOverrides, BandRef, RasterRef};
-use crate::view_entries::ViewEntry;
+use crate::traits::{BandOverrides, BandRef, Override, RasterRef};
+use crate::view_entries::{ViewEntries, ViewEntry};
 
 /// Raster-level metadata overrides for [`RasterBuilder::start_raster_from`] and
 /// [`RasterBuilder::copy_raster_from`]. A `None` field inherits the source
@@ -394,22 +394,27 @@ impl RasterBuilder {
             outdb_uri,
             outdb_format,
         } = args;
-        // Delegate to `copy_into`, which composes `view` (a delta over the
-        // input's visible axes) onto the input's own view, carries the source
-        // bytes over, and inherits every field left unset here from the input
-        // via `.or_else(|| input.<field>())` — including `nodata`, which the
-        // earlier hand-rolled implementation forwarded verbatim and thereby
-        // dropped. `dim_names` and `view` are always supplied by this call, so
-        // they pass through as explicit overrides.
+        // `copy_into` never composes the view, so compose the delta here:
+        // `view` addresses `input`'s *visible* axes, and composing it onto
+        // `input.view()` yields the absolute source-space view that `copy_into`
+        // persists verbatim (`Override::Set`). `compose` also bounds the delta
+        // against the parent's visible window, so a slice can't re-expose bytes
+        // the input had already sliced away.
+        let composed =
+            ViewEntries::new(input.view().to_vec()).compose(&ViewEntries::new(view.to_vec()))?;
+        // Everything the caller leaves unset inherits from the source via
+        // `Override::Keep`, including `nodata` — the source's sentinel must
+        // carry over rather than being dropped. An explicit caller value
+        // becomes `Override::Set`.
         input.copy_into(
             self,
             BandOverrides {
-                name,
+                name: name.map_or(Override::Keep, Override::Set),
                 dim_names: Some(dim_names),
-                nodata,
-                outdb_uri,
-                outdb_format,
-                view: Some(view),
+                nodata: nodata.map_or(Override::Keep, Override::Set),
+                outdb_uri: outdb_uri.map_or(Override::Keep, Override::Set),
+                outdb_format: outdb_format.map_or(Override::Keep, Override::Set),
+                view: Override::Set(composed.as_slice()),
             },
         )
     }