diesel-rs/diesel · error · std::io::Error

out of range integral type conversion attempted

Error message

out of range integral type conversion attempted

What it means

A `TryFromIntError` from a failed integer conversion (e.g. `usize -> u32` via `try_into`) was wrapped into a `std::io::Error` with kind `InvalidInput`. Diesel's SQLite blob I/O adapters convert file offsets/sizes to SQLite's expected integer types, and this fires when a value does not fit the target integral type.

Solutions

1. Check the offset/length values passed to the blob read/write APIs; keep them within `i32`/`u32` range
2. Compute sizes/offsets with checked arithmetic (`checked_add`/`try_into`) before passing them in
3. If the blob genuinely exceeds the limit, split it or use a different storage strategy
4. Inspect the underlying `TryFromIntError` message to identify which conversion overflowed

Example fix

// before
let offset: u32 = huge_usize.try_into().unwrap();
// after
let offset: u32 = u32::try_from(huge_usize).map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;

fn valid_blob_range(offset: usize, len: usize) -> bool {
    u32::try_from(offset).is_ok() && u32::try_from(len).is_ok() && offset.checked_add(len).is_some()
}

When it happens

Trigger: Using `SqliteReadOnlyBlob`/blob IO helpers where an offset, length, or size value exceeds the range of the target integer type during the conversion performed in `to_io_error`.

Common situations: Reading or writing a blob region with an offset/length larger than 2^31-1 (exceeding `i32`/`u32` bounds), often from very large blobs or bad computed offsets on 64-bit platforms.

Understand the failure class

Background: "value must be between 0 and 1" / "out of range" / "must not be negative" errors: fixing range-validation failures across open-source libraries — this error's family across 42 libraries.

Related errors

• Error closing SQLite connection
• Error closing SQLite blob
• Sqlite's documentation state that this case
• You've reached an impossible internal state. If you ever…
• unexpected end of input, expected parentheses help: the…

AI-assisted analysis of diesel-rs/diesel@6fa6ed01b2 (2026-09-07). Data as JSON: /api/errors/e639466976837389. Report an issue: GitHub.

Appendix: source

Thrown at diesel/src/sqlite/connection/sqlite_blob.rs:85

        //     If an error occurs while committing the transaction, an error code is returned and
        //     the transaction rolled back.
        //
        // As we are in read-only mode here, this is not an issue
        let close_result = unsafe { ffi::sqlite3_blob_close(self.blob.as_ptr()) };

        if close_result != ffi::SQLITE_OK {
            let error_message = super::error_message(close_result);
            return Err(crate::result::Error::ClosingHandle(error_message));
        }

        Ok(())
    }
}

#[cfg(feature = "std")]
#[allow(clippy::std_instead_of_core)] // needs a newer rust version
fn to_io_error(error: core::num::TryFromIntError) -> std::io::Error {
    std::io::Error::new(std::io::ErrorKind::InvalidInput, Box::new(error))
}

// SEE https://github.com/rust-lang/rust/issues/48331
#[cfg(feature = "std")]
impl std::io::Read for SqliteReadOnlyBlob<'_> {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        let buflen: i32 = buf.len().try_into().map_err(to_io_error)?;
        let offset: i32 = self.read_index.try_into().map_err(to_io_error)?;

        // From the sqlite docs:
        //
        // > If offset iOffset is less than N bytes from the end of the BLOB, SQLITE_ERROR is returned and no data is read.
        //
        // Thus we need to make sure to not provide a buffer that is too big for the remaining data
        // from the blob.
        let read_length: i32 = (i32::try_from(self.blob_size)
            .map_err(to_io_error)?
            .saturating_sub(offset))

View on GitHub (pinned to 6fa6ed01b2)