Struct SqlUint 

pub struct SqlUint<const BITS: usize, const LIMBS: usize>(/* private fields */);

A SQL-compatible wrapper for 256-bit unsigned integers.

SqlU256 wraps alloy::primitives::U256 and implements all necessary traits for seamless SQLx database integration. It provides full arithmetic operations, type conversions, and consistent hexadecimal storage format across databases.

Features

• Arithmetic Operations: Supports +, -, *, /, %, bitwise operations, and more
• Type Conversions: Convert from/to various integer types with overflow checking
• Database Storage: Consistent hexadecimal format (0x…) across all databases
• Input Flexibility: FromStr accepts both decimal and hexadecimal strings
• SQLx Integration: Implements Type, Encode, and Decode for MySQL, PostgreSQL, SQLite

Examples

use ethereum_mysql::SqlU256;
use alloy::primitives::U256;
use std::str::FromStr;

// Create from various types
let from_u64 = SqlU256::from(42u64);
let from_decimal = SqlU256::from_str("123456789").unwrap();
let from_hex = SqlU256::from_str("0x75bcd15").unwrap();
let zero = SqlU256::ZERO;

// Arithmetic operations
let a = SqlU256::from(100u64);
let b = SqlU256::from(50u64);
let sum = a + b;                    // 150
let product = a * b;                // 5000
let power = a.pow(2);               // 10000

// Safe operations
let checked = a.checked_add(b);     // Some(150)
let saturated = a.saturating_sub(SqlU256::from(200u64)); // 0

// Type conversions
let back_to_u256: U256 = from_u64.into();  // SqlU256 -> U256 (always safe)
let back_to_u64: u64 = from_u64.try_into().unwrap(); // SqlU256 -> u64 (may overflow)

Implementations

impl SqlUint<256, 4>

pub fn square(self) -> Self

Returns the square of this value

pub fn pow(self, exp: usize) -> Self

Returns the power of this value raised to the given exponent

pub fn gcd(self, other: Self) -> Self

Returns the greatest common divisor of two values

pub fn lcm(self, other: Self) -> Self

Returns the least common multiple of two values

pub fn checked_add(self, rhs: Self) -> Option<Self>

Checked addition. Returns None if overflow occurred.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Checked subtraction. Returns None if overflow occurred.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Checked multiplication. Returns None if overflow occurred.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Checked division. Returns None if rhs == 0.

pub fn saturating_add(self, rhs: Self) -> Self

Saturating addition. Clamps the result to U256::MAX if overflow occurred.

pub fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction. Clamps the result to 0 if underflow occurred.

pub fn saturating_mul(self, rhs: Self) -> Self

Saturating multiplication. Clamps the result to U256::MAX if overflow occurred.

pub fn is_zero(self) -> bool

Returns true if the value is zero

pub fn min(self, other: Self) -> Self

Returns the minimum of two values

pub fn max(self, other: Self) -> Self

Returns the maximum of two values

impl<const BITS: usize, const LIMBS: usize> SqlUint<BITS, LIMBS>

pub const ZERO: Self

Creates a new SqlUint from a Uint value.

Examples

Equivalent to SqlU256::from(0u64) but available as a compile-time constant.

pub fn inner(&self) -> &Uint<BITS, LIMBS>

Returns a reference to the inner U256 value.

This is useful when you need to interact with APIs that expect U256 directly.

Examples

use ethereum_mysql::SqlU256;

let sql_u256 = SqlU256::from(42u64);
let inner_ref: &alloy::primitives::U256 = sql_u256.inner();

pub fn into_inner(self) -> Uint<BITS, LIMBS>

Consumes self and returns the inner Uint value.

impl SqlUint<256, 4>

pub const ETHER: Self

The number of wei in one ether (10^18).

pub fn from_be_slice(bytes: &[u8]) -> Self

Creates a SqlU256 from a big-endian byte slice (pads/truncates as alloy U256).

pub fn as_u8(&self) -> Result<u8, &'static str>

Try to convert this value to u8. Returns Err if out of range.

pub fn as_u16(&self) -> Result<u16, &'static str>

Try to convert this value to u16. Returns Err if out of range.

pub fn as_u32(&self) -> Result<u32, &'static str>

Try to convert this value to u32. Returns Err if out of range.

pub fn as_u64(&self) -> Result<u64, &'static str>

Try to convert this value to u64. Returns Err if out of range.

pub fn as_u128(&self) -> Result<u128, &'static str>

Try to convert this value to u128. Returns Err if out of range.

Methods from Deref<Target = Uint<BITS, LIMBS>>

pub fn to_base_le(&self, base: u64) -> impl Iterator<Item = u64>

Returns an iterator over the base base digits of the number in little-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

Panics

Panics if the base is less than 2.

pub fn to_base_be(&self, base: u64) -> impl Iterator<Item = u64>

Returns an iterator over the base base digits of the number in big-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

Panics

Panics if the base is less than 2.

pub fn bit(&self, index: usize) -> bool

Returns whether a specific bit is set.

Returns false if index exceeds the bit width of the number.

pub fn byte(&self, index: usize) -> u8

Returns a specific byte. The byte at index 0 is the least significant byte (little endian).

Panics

Panics if index is greater than or equal to the byte width of the number.

Examples

let x = uint!(0x1234567890_U64);
let bytes = [
    x.byte(0), // 0x90
    x.byte(1), // 0x78
    x.byte(2), // 0x56
    x.byte(3), // 0x34
    x.byte(4), // 0x12
    x.byte(5), // 0x00
    x.byte(6), // 0x00
    x.byte(7), // 0x00
];
assert_eq!(bytes, x.to_le_bytes());

Panics if out of range.

let x = uint!(0x1234567890_U64);
let _ = x.byte(8);

pub fn checked_byte(&self, index: usize) -> Option<u8>

Returns a specific byte, or None if index is out of range. The byte at index 0 is the least significant byte (little endian).

Examples

let x = uint!(0x1234567890_U64);
assert_eq!(x.checked_byte(0), Some(0x90));
assert_eq!(x.checked_byte(7), Some(0x00));
// Out of range
assert_eq!(x.checked_byte(8), None);

pub fn leading_zeros(&self) -> usize

Returns the number of leading zeros in the binary representation of self.

pub fn leading_ones(&self) -> usize

Returns the number of leading ones in the binary representation of self.

pub fn trailing_zeros(&self) -> usize

Returns the number of trailing zeros in the binary representation of self.

pub fn trailing_ones(&self) -> usize

Returns the number of trailing ones in the binary representation of self.

pub fn count_ones(&self) -> usize

Returns the number of ones in the binary representation of self.

pub fn count_zeros(&self) -> usize

Returns the number of zeros in the binary representation of self.

pub fn bit_len(&self) -> usize

Returns the dynamic length of this number in bits, ignoring leading zeros.

For the maximum length of the type, use Uint::BITS.

pub fn byte_len(&self) -> usize

Returns the dynamic length of this number in bytes, ignoring leading zeros.

For the maximum length of the type, use Uint::BYTES.

pub fn most_significant_bits(&self) -> (u64, usize)

Returns the most significant 64 bits of the number and the exponent.

Given return value $(\mathtt{bits}, \mathtt{exponent})$, the self can be approximated as

$$ \mathtt{self} ≈ \mathtt{bits} ⋅ 2^\mathtt{exponent} $$

If self is $<≥> 2^{63}$, then exponent will be zero and bits will have leading zeros.

pub const BYTES: usize

pub fn as_le_slice(&self) -> &[u8]

Access the underlying store as a little-endian slice of bytes.

Only available on little-endian targets.

If BITS does not evenly divide 8, it is padded with zero bits in the most significant position.

pub fn as_le_bytes(&self) -> Cow<'_, [u8]>

Access the underlying store as a little-endian bytes.

Uses an optimized implementation on little-endian targets.

pub fn as_le_bytes_trimmed(&self) -> Cow<'_, [u8]>

Access the underlying store as a little-endian bytes with trailing zeros removed.

Uses an optimized implementation on little-endian targets.

pub fn to_le_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Converts the Uint to a little-endian byte array of size exactly Self::BYTES.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_le_bytes_vec(&self) -> Vec<u8>

Converts the Uint to a little-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_le_bytes can not be used because byte size is not known compile time.

pub fn to_le_bytes_trimmed_vec(&self) -> Vec<u8>

Converts the Uint to a little-endian byte vector with trailing zeros bytes removed.

pub fn to_be_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Converts the Uint to a big-endian byte array of size exactly Self::BYTES.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_be_bytes_vec(&self) -> Vec<u8>

Converts the Uint to a big-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_be_bytes can not be used because byte size is not known compile time.

pub fn to_be_bytes_trimmed_vec(&self) -> Vec<u8>

Converts the Uint to a big-endian byte vector with leading zeros bytes removed.

pub fn copy_le_bytes_to(&self, buf: &mut [u8]) -> usize

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_le_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn copy_be_bytes_to(&self, buf: &mut [u8]) -> usize

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_be_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn is_zero(&self) -> bool

Returns true if the value is zero.

pub fn const_is_zero(&self) -> bool

Returns true if the value is zero.

Note that this currently might perform worse than is_zero.

pub fn const_eq(&self, other: &Uint<BITS, LIMBS>) -> bool

Returns true if self equals other.

Note that this currently might perform worse than the derived PartialEq (== operator).

pub fn to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>, T: Debug,

Panics

Panics if the conversion fails, for example if the value is too large for the bit-size of the target type.

Examples

assert_eq!(300_U12.to::<i16>(), 300_i16);
assert_eq!(300_U12.to::<U256>(), 300_U256);

pub fn wrapping_to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>,

Examples

assert_eq!(300_U12.wrapping_to::<i8>(), 44_i8);
assert_eq!(255_U32.wrapping_to::<i8>(), -1_i8);
assert_eq!(0x1337cafec0d3_U256.wrapping_to::<U32>(), 0xcafec0d3_U32);

pub fn saturating_to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>,

Examples

assert_eq!(300_U12.saturating_to::<i16>(), 300_i16);
assert_eq!(255_U32.saturating_to::<i8>(), 127);
assert_eq!(0x1337cafec0d3_U256.saturating_to::<U32>(), U32::MAX);

pub const LIMBS: usize

pub const MASK: u64

pub const BITS: usize = BITS

pub const ZERO: Uint<BITS, LIMBS>

pub const ONE: Uint<BITS, LIMBS>

pub const MIN: Uint<BITS, LIMBS> = Self::ZERO

pub const MAX: Uint<BITS, LIMBS>

pub fn as_limbs(&self) -> &[u64; LIMBS]

View the array of limbs.

Trait Implementations

impl Add<&SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: &SqlU256) -> Self::Output

Performs the + operation.

impl Add<&SqlUint<256, 4>> for SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for i128

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for i16

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for i32

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for i64

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for i8

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for isize

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for u128

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for u16

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for u32

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for u64

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for u8

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl Add<SqlUint<256, 4>> for usize

type Output = SqlUint<256, 4>

The resulting type after applying the + operator.

fn add(self, rhs: SqlU256) -> Self::Output

Performs the + operation.

impl AddAssign<&SqlUint<256, 4>> for SqlU256

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const BITS: usize, const LIMBS: usize> AsRef<Uint<BITS, LIMBS>> for SqlUint<BITS, LIMBS>

fn as_ref(&self) -> &Uint<BITS, LIMBS>

Converts this type into a shared reference of the (usually inferred) input type.

impl<const BITS: usize, const LIMBS: usize> Clone for SqlUint<BITS, LIMBS>

fn clone(&self) -> SqlUint<BITS, LIMBS>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const BITS: usize, const LIMBS: usize> Debug for SqlUint<BITS, LIMBS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, const BITS: usize, const LIMBS: usize, DB: Database> Decode<'a, DB> for SqlUint<BITS, LIMBS>

where String: Decode<'a, DB>,

Available on crate feature sqlx only.

fn decode(value: <DB as Database>::ValueRef<'a>) -> Result<Self, BoxDynError>

Decode a new value of this type using a raw value from the database.

impl<const BITS: usize, const LIMBS: usize> Deref for SqlUint<BITS, LIMBS>

type Target = Uint<BITS, LIMBS>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, const BITS: usize, const LIMBS: usize> Deserialize<'de> for SqlUint<BITS, LIMBS>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const BITS: usize, const LIMBS: usize> Display for SqlUint<BITS, LIMBS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<&SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: &SqlU256) -> Self::Output

Performs the / operation.

impl Div<&SqlUint<256, 4>> for SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl Div<SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: SqlU256) -> Self::Output

Performs the / operation.

impl Div<SqlUint<256, 4>> for u128

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: SqlU256) -> Self::Output

Performs the / operation.

impl Div<SqlUint<256, 4>> for u16

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: SqlU256) -> Self::Output

Performs the / operation.

impl Div<SqlUint<256, 4>> for u32

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: SqlU256) -> Self::Output

Performs the / operation.

impl Div<SqlUint<256, 4>> for u64

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: SqlU256) -> Self::Output

Performs the / operation.

impl Div<SqlUint<256, 4>> for u8

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: SqlU256) -> Self::Output

Performs the / operation.

impl Div<SqlUint<256, 4>> for usize

type Output = SqlUint<256, 4>

The resulting type after applying the / operator.

fn div(self, rhs: SqlU256) -> Self::Output

Performs the / operation.

impl DivAssign<&SqlUint<256, 4>> for SqlU256

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<'a, const BITS: usize, const LIMBS: usize, DB: Database> Encode<'a, DB> for SqlUint<BITS, LIMBS>

where String: Encode<'a, DB>,

Available on crate feature sqlx only.

fn encode_by_ref( &self, buf: &mut <DB as Database>::ArgumentBuffer<'a>, ) -> Result<IsNull, BoxDynError>

Writes the value of self into buf without moving self.

fn encode( self, buf: &mut <DB as Database>::ArgumentBuffer<'q>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

where Self: Sized,

Writes the value of self into buf in the expected format for the database.

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

fn size_hint(&self) -> usize

impl<const BITS: usize, const LIMBS: usize> From<SqlUint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn from(value: SqlUint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for SqlUint<BITS, LIMBS>

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> FromStr for SqlUint<BITS, LIMBS>

type Err = <Uint<BITS, LIMBS> as FromStr>::Err

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<const BITS: usize, const LIMBS: usize> Hash for SqlUint<BITS, LIMBS>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const BITS: usize, const LIMBS: usize> LowerHex for SqlUint<BITS, LIMBS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Mul<&SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: &SqlU256) -> Self::Output

Performs the * operation.

impl Mul<&SqlUint<256, 4>> for SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for i128

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for i16

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for i32

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for i64

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for i8

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for isize

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for u128

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for u16

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for u32

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for u64

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for u8

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl Mul<SqlUint<256, 4>> for usize

type Output = SqlUint<256, 4>

The resulting type after applying the * operator.

fn mul(self, rhs: SqlU256) -> Self::Output

Performs the * operation.

impl MulAssign<&SqlUint<256, 4>> for SqlU256

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const BITS: usize, const LIMBS: usize> Ord for SqlUint<BITS, LIMBS>

fn cmp(&self, other: &SqlUint<BITS, LIMBS>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<SqlUint<256, 4>> for u128

fn eq(&self, other: &SqlU256) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<SqlUint<256, 4>> for u16

fn eq(&self, other: &SqlU256) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<SqlUint<256, 4>> for u32

fn eq(&self, other: &SqlU256) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<SqlUint<256, 4>> for u64

fn eq(&self, other: &SqlU256) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<SqlUint<256, 4>> for u8

fn eq(&self, other: &SqlU256) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const BITS: usize, const LIMBS: usize> PartialEq for SqlUint<BITS, LIMBS>

fn eq(&self, other: &SqlUint<BITS, LIMBS>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<SqlUint<256, 4>> for u128

fn partial_cmp(&self, other: &SqlU256) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<SqlUint<256, 4>> for u16

fn partial_cmp(&self, other: &SqlU256) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<SqlUint<256, 4>> for u32

fn partial_cmp(&self, other: &SqlU256) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<SqlUint<256, 4>> for u64

fn partial_cmp(&self, other: &SqlU256) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<SqlUint<256, 4>> for u8

fn partial_cmp(&self, other: &SqlU256) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd for SqlUint<BITS, LIMBS>

fn partial_cmp(&self, other: &SqlUint<BITS, LIMBS>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rem<&SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: &SqlU256) -> Self::Output

Performs the % operation.

impl Rem<&SqlUint<256, 4>> for SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl Rem<SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: SqlU256) -> Self::Output

Performs the % operation.

impl Rem<SqlUint<256, 4>> for u128

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: SqlU256) -> Self::Output

Performs the % operation.

impl Rem<SqlUint<256, 4>> for u16

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: SqlU256) -> Self::Output

Performs the % operation.

impl Rem<SqlUint<256, 4>> for u32

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: SqlU256) -> Self::Output

Performs the % operation.

impl Rem<SqlUint<256, 4>> for u64

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: SqlU256) -> Self::Output

Performs the % operation.

impl Rem<SqlUint<256, 4>> for u8

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: SqlU256) -> Self::Output

Performs the % operation.

impl Rem<SqlUint<256, 4>> for usize

type Output = SqlUint<256, 4>

The resulting type after applying the % operator.

fn rem(self, rhs: SqlU256) -> Self::Output

Performs the % operation.

impl RemAssign<&SqlUint<256, 4>> for SqlU256

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const BITS: usize, const LIMBS: usize> Serialize for SqlUint<BITS, LIMBS>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<&SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: &SqlU256) -> Self::Output

Performs the - operation.

impl Sub<&SqlUint<256, 4>> for SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl Sub<SqlUint<256, 4>> for &SqlU256

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: SqlU256) -> Self::Output

Performs the - operation.

impl Sub<SqlUint<256, 4>> for u128

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: SqlU256) -> Self::Output

Performs the - operation.

impl Sub<SqlUint<256, 4>> for u16

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: SqlU256) -> Self::Output

Performs the - operation.

impl Sub<SqlUint<256, 4>> for u32

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: SqlU256) -> Self::Output

Performs the - operation.

impl Sub<SqlUint<256, 4>> for u64

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: SqlU256) -> Self::Output

Performs the - operation.

impl Sub<SqlUint<256, 4>> for u8

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: SqlU256) -> Self::Output

Performs the - operation.

impl Sub<SqlUint<256, 4>> for usize

type Output = SqlUint<256, 4>

The resulting type after applying the - operator.

fn sub(self, rhs: SqlU256) -> Self::Output

Performs the - operation.

impl SubAssign<&SqlUint<256, 4>> for SqlU256

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl TryFrom<SqlUint<256, 4>> for u128

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: SqlU256) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<SqlUint<256, 4>> for u16

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: SqlU256) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<SqlUint<256, 4>> for u32

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: SqlU256) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<SqlUint<256, 4>> for u64

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: SqlU256) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<SqlUint<256, 4>> for u8

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: SqlU256) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<SqlUint<256, 4>> for usize

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: SqlU256) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize, DB: Database> Type<DB> for SqlUint<BITS, LIMBS>

where String: Type<DB>,

Available on crate feature sqlx only.

fn type_info() -> DB::TypeInfo

Returns the canonical SQL type for this Rust type.

fn compatible(ty: &DB::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type.

impl<const BITS: usize, const LIMBS: usize> UpperHex for SqlUint<BITS, LIMBS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const BITS: usize, const LIMBS: usize> Copy for SqlUint<BITS, LIMBS>

impl<const BITS: usize, const LIMBS: usize> Eq for SqlUint<BITS, LIMBS>

impl<const BITS: usize, const LIMBS: usize> StructuralPartialEq for SqlUint<BITS, LIMBS>