Method new_unchecked

arrow-array/src/array/run_array.rs:150–202

Create a new [`RunArray`] from the provided parts, without validation # Safety Safe if [`Self::try_new`] would not error

(
        data_type: DataType,
        run_ends: RunEndBuffer<R::Native>,
        values: ArrayRef,
    )

    ///
    /// Safe if [`Self::try_new`] would not error
    pub unsafe fn new_unchecked(
        data_type: DataType,
        run_ends: RunEndBuffer<R::Native>,
        values: ArrayRef,
    ) -> Self {
        if cfg!(feature = "force_validate") {
            match &data_type {
                DataType::RunEndEncoded(run_ends, values_field) => {
                    assert!(!run_ends.is_nullable(), "run_ends should not be nullable");
                    assert_eq!(
                        run_ends.data_type(),
                        &R::DATA_TYPE,
                        "Incorrect run ends type"
                    );
                    assert_eq!(
                        values_field.data_type(),
                        values.data_type(),
                        "Incorrect values type"
                    );
                }
                _ => {
                    panic!(
                        "Invalid data type {data_type:?} for RunArray. Should be DataType::RunEndEncoded"
                    );
                }
            }

            let run_array = Self {
                data_type,
                run_ends,
                values,
            };

            // Safety: `validate_data` checks below
            //    1. The given array data has exactly two child arrays.
            //    2. The first child array (run_ends) has valid data type.
            //    3. run_ends array does not have null values
            //    4. run_ends array has non-zero and strictly increasing values.
            //    5. The length of run_ends array and values array are the same.
            run_array
                .to_data()
                .validate_data()
                .expect("RunArray data should be valid");

            return run_array;
        }

        Self {
            data_type,
            run_ends,
            values,
        }
    }

    /// Deconstruct this array into its constituent parts
    pub fn into_parts(self) -> (DataType, RunEndBuffer<R::Native>, ArrayRef) {