@@ -16,8 +16,20 @@ use crate::scalar_fn::fns::cast::CastReduce;
 
 impl CastReduce for Dict {
     fn cast(array: ArrayView<'_, Dict>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
-        // Can have un-reference null values making the cast of values fail without a possible mask.
-        // TODO(joe): optimize this, could look at accessible values and fill_null not those?
+        // Casting unused entries must not introduce errors that a cast over the rows would skip.
+        if !array.has_all_values_referenced() {
+            let safe_for_unused_values = match (array.dtype(), dtype) {
+                (DType::Primitive(from, _), DType::Primitive(to, _)) => {
+                    from.casts_losslessly_to(*to)
+                }
+                (from, to) => from.as_nullable() == to.as_nullable(),
+            };
+            if !safe_for_unused_values {
+                return Ok(None);
+            }
+        }
+
+        // An unused null entry must not make a cast to a non-nullable dtype fail.
         if !dtype.is_nullable() && !array.values().validity()?.definitely_no_nulls() {
             return Ok(None);
         }
@@ -51,9 +63,11 @@ mod tests {
     use rstest::rstest;
     use vortex_buffer::BitBuffer;
     use vortex_buffer::buffer;
+    use vortex_error::VortexResult;
     use vortex_session::VortexSession;
 
     use crate::ArrayRef;
+    use crate::Canonical;
     use crate::IntoArray;
     use crate::VortexSessionExecute;
     use crate::arrays::Dict;
@@ -229,4 +243,58 @@ mod tests {
         );
         assert_arrays_eq!(casted, PrimitiveArray::from_iter([1.0f64, 3.0, 1.0]), ctx);
     }
+
+    /// Slicing keeps the whole dictionary, so the value `1000` stays in `values` although no
+    /// remaining row references it. The cast must only consider the rows: `[1, 1, 1]` fits in i8.
+    #[test]
+    fn test_cast_dict_after_slice_ignores_unreferenced_values() -> VortexResult<()> {
+        let ctx = &mut SESSION.create_execution_ctx();
+        let dict = dict_encode(&buffer![1000i64, 1, 1, 1].into_array(), ctx)?;
+        let rows = dict.into_array().slice(1..4)?.optimize_ctx(&SESSION)?;
+
+        let casted = rows
+            .cast(DType::Primitive(PType::I8, Nullability::NonNullable))?
+            .optimize_ctx(&SESSION)?
+            .execute::<Canonical>(ctx)?;
+
+        assert_arrays_eq!(casted, PrimitiveArray::from_iter([1i8, 1, 1]), ctx);
+        Ok(())
+    }
+
+    #[test]
+    fn test_cast_dict_with_unreferenced_values_preserves_nullability_rewrite() -> VortexResult<()> {
+        let ctx = &mut SESSION.create_execution_ctx();
+        let dict = DictArray::try_new(
+            buffer![1u8, 1, 1].into_array(),
+            buffer![1000i64, 1].into_array(),
+        )?
+        .into_array();
+
+        let nullable = dict
+            .cast(DType::Primitive(PType::I64, Nullability::Nullable))?
+            .optimize_ctx(&SESSION)?;
+        assert!(nullable.is::<Dict>());
+        let non_nullable = nullable
+            .cast(DType::Primitive(PType::I64, Nullability::NonNullable))?
+            .optimize_ctx(&SESSION)?;
+        assert!(non_nullable.is::<Dict>());
+
+        assert_arrays_eq!(non_nullable, PrimitiveArray::from_iter([1i64, 1, 1]), ctx);
+        Ok(())
+    }
+
+    #[test]
+    fn test_cast_dict_rejects_referenced_out_of_range_value() -> VortexResult<()> {
+        let ctx = &mut SESSION.create_execution_ctx();
+        let dict = dict_encode(&buffer![1000i64, 1, 1, 1].into_array(), ctx)?;
+        let casted = dict
+            .into_array()
+            .cast(DType::Primitive(PType::I8, Nullability::NonNullable))?
+            .optimize_ctx(&SESSION)?;
+
+        assert!(casted.is::<Dict>());
+        let error = casted.execute::<Canonical>(ctx).unwrap_err();
+        assert!(error.to_string().contains("value exceeds target range"));
+        Ok(())
+    }
 }
@@ -268,6 +268,12 @@ impl ArrayParentReduceRule<Dict> for DictionaryScalarFnCodesPullUpRule {
             return Ok(None);
         }
 
+        // Pulling up the codes evaluates every dictionary value, including unreferenced entries
+        // on which a fallible function could fail even though no row would evaluate them.
+        if !array.has_all_values_referenced() && !parent.scalar_fn().signature().is_infallible() {
+            return Ok(None);
+        }
+
         // Check that all siblings are dictionaries, and have the same number of values as us.
         // This is a cheap first loop.
         if !parent.iter_children().enumerate().all(|(idx, c)| {
@@ -310,11 +316,13 @@ impl ArrayParentReduceRule<Dict> for DictionaryScalarFnCodesPullUpRule {
 mod tests {
     use std::sync::LazyLock;
 
+    use rstest::rstest;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
     use vortex_session::VortexSession;
 
     use crate::ArrayRef;
+    use crate::Canonical;
     use crate::IntoArray;
     use crate::arrays::BoolArray;
     use crate::arrays::Chunked;
@@ -444,4 +452,77 @@ mod tests {
         assert_arrays_eq!(optimized, expected, &mut ctx);
         Ok(())
     }
+
+    /// Both slices share the codes `[1, 1, 1]`, so the codes pull-up divides the two values
+    /// arrays. The divisor still holds the unreferenced `0`, which no row divides by, so the
+    /// result must be `[8, 8, 8] / [2, 2, 2]`.
+    #[test]
+    fn codes_pull_up_skips_fallible_fn_over_unreferenced_values() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let dividend = DictArray::try_new(
+            buffer![0u8, 1, 1, 1].into_array(),
+            buffer![7i32, 8].into_array(),
+        )?
+        .into_array()
+        .slice(1..4)?
+        .optimize_ctx(&SESSION)?;
+        let divisor = DictArray::try_new(
+            buffer![0u8, 1, 1, 1].into_array(),
+            buffer![0i32, 2].into_array(),
+        )?
+        .into_array()
+        .slice(1..4)?
+        .optimize_ctx(&SESSION)?;
+        let expr = Binary::try_new(dividend, divisor, Operator::Div)?.into_array();
+
+        let quotient = expr
+            .optimize_ctx(&SESSION)?
+            .execute::<Canonical>(&mut ctx)?;
+
+        assert_arrays_eq!(quotient, PrimitiveArray::from_iter([4i32, 4, 4]), &mut ctx);
+        Ok(())
+    }
+
+    #[rstest]
+    #[case::infallible(false, Operator::Eq, BoolArray::from_iter([false, true, false, true]).into_array())]
+    #[case::all_values_referenced(true, Operator::Div, buffer![4i32, 1, 4, 1].into_array())]
+    fn codes_pull_up_preserves_safe_rewrites(
+        #[case] all_values_referenced: bool,
+        #[case] operator: Operator,
+        #[case] expected: ArrayRef,
+    ) -> VortexResult<()> {
+        let codes = buffer![0u8, 1, 0, 1].into_array();
+        // SAFETY: Both dictionary entries are referenced by valid codes.
+        let lhs = unsafe {
+            DictArray::try_new(codes.clone(), buffer![8i32, 9].into_array())?
+                .set_all_values_referenced(all_values_referenced)
+        }
+        .into_array();
+        let rhs = DictArray::try_new(codes, buffer![2i32, 9].into_array())?.into_array();
+
+        let optimized = Binary::try_new(lhs, rhs, operator)?
+            .into_array()
+            .optimize_ctx(&SESSION)?;
+        assert!(optimized.is::<Dict>());
+        let mut ctx = SESSION.create_execution_ctx();
+        let result = optimized.execute::<Canonical>(&mut ctx)?;
+        assert_arrays_eq!(result, expected, &mut ctx);
+        Ok(())
+    }
+
+    #[test]
+    fn codes_pull_up_rejects_referenced_zero_divisor() -> VortexResult<()> {
+        let codes = buffer![0u8, 1, 0, 1].into_array();
+        let dividend =
+            DictArray::try_new(codes.clone(), buffer![7i32, 8].into_array())?.into_array();
+        let divisor = DictArray::try_new(codes, buffer![0i32, 2].into_array())?.into_array();
+        let expr = Binary::try_new(dividend, divisor, Operator::Div)?.into_array();
+
+        let error = expr
+            .optimize_ctx(&SESSION)?
+            .execute::<Canonical>(&mut SESSION.create_execution_ctx())
+            .unwrap_err();
+        assert!(error.to_string().contains("division by zero"));
+        Ok(())
+    }
 }
@@ -519,35 +519,9 @@ where
         )
     };
 
-    // Returns `true` if every value of `from` is representable in `to` without loss.
-    fn casts_losslessly_to(from: PType, to: PType) -> bool {
-        if from == to {
-            return true;
-        }
-        if (from.is_unsigned_int() && to.is_unsigned_int())
-            || (from.is_signed_int() && to.is_signed_int())
-            || (from.is_float() && to.is_float())
-        {
-            return from.byte_width() <= to.byte_width();
-        }
-        if from.is_unsigned_int() && to.is_signed_int() {
-            return from.byte_width() < to.byte_width();
-        }
-        if from.is_int() && to.is_float() {
-            let minimum_float_width = match from.byte_width() {
-                1 => 2,
-                2 => 4,
-                4 => 8,
-                _ => return false,
-            };
-            return to.byte_width() >= minimum_float_width;
-        }
-        false
-    }
-
     // Skip the fallible kernel when type widening or (cached) min/max prove every value fits.
     let target_dtype = DType::Primitive(T::PTYPE, Nullability::NonNullable);
-    let infallible = casts_losslessly_to(F::PTYPE, T::PTYPE)
+    let infallible = F::PTYPE.casts_losslessly_to(T::PTYPE)
         || cached_values_fit_in(array, &target_dtype).unwrap_or(false);
 
     let len = array.len();
 
@@ -827,6 +827,32 @@ impl PType {
         self.byte_width() * 8
     }
 
+    /// Returns whether every value of this type is representable in `to` without loss.
+    pub(crate) fn casts_losslessly_to(self, to: Self) -> bool {
+        if self == to {
+            return true;
+        }
+        if (self.is_unsigned_int() && to.is_unsigned_int())
+            || (self.is_signed_int() && to.is_signed_int())
+            || (self.is_float() && to.is_float())
+        {
+            return self.byte_width() <= to.byte_width();
+        }
+        if self.is_unsigned_int() && to.is_signed_int() {
+            return self.byte_width() < to.byte_width();
+        }
+        if self.is_int() && to.is_float() {
+            let minimum_float_width = match self.byte_width() {
+                1 => 2,
+                2 => 4,
+                4 => 8,
+                _ => return false,
+            };
+            return to.byte_width() >= minimum_float_width;
+        }
+        false
+    }
+
     /// Returns the maximum value of this PType if it is an integer type
     /// Returns `u64::MAX` if the value is too large to fit in a `u64`
     #[inline]