Struct Decimal64NoScale 

pub struct Decimal64NoScale { /* private fields */ }

A fixed-precision decimal stored as a raw 64-bit integer.

Design

Unlike Decimal64 which embeds scale, Decimal64NoScale stores only the mantissa. This provides:

• 2 more digits of precision (18 vs 16)
• Correct aggregates (sum/min/max work with raw integer math)
• Columnar storage compatibility (scale in metadata, not per-value)

Aggregates

stored_values = [a*10^s, b*10^s, c*10^s]
SUM(stored_values) = (a+b+c) * 10^s
actual_sum = SUM / 10^s = a+b+c  ✓

Special Values

Special values use sentinel i64 values (at the extremes of the range):

• i64::MIN: NaN (sorts highest per PostgreSQL semantics)
• i64::MIN + 1: -Infinity (sorts lowest)
• i64::MAX: +Infinity

Implementations

impl Decimal64NoScale

pub fn new(s: &str, scale: i32) -> Result<Self, DecimalError>

Creates a Decimal64NoScale from a string with the given scale.

Arguments

• s - The decimal string (e.g., “123.45”)
• scale - The number of decimal places to store

Examples

use decimal_bytes::Decimal64NoScale;

let d = Decimal64NoScale::new("123.45", 2).unwrap();
assert_eq!(d.value(), 12345);
assert_eq!(d.to_string_with_scale(2), "123.45");

pub const fn from_raw(value: i64) -> Self

Creates a Decimal64NoScale from a raw i64 value.

Use this when you already have the scaled integer value.

Examples

use decimal_bytes::Decimal64NoScale;

let d = Decimal64NoScale::from_raw(12345);
assert_eq!(d.value(), 12345);
assert_eq!(d.to_string_with_scale(2), "123.45");

pub const fn infinity() -> Self

Creates positive infinity.

pub const fn neg_infinity() -> Self

Creates negative infinity.

pub const fn nan() -> Self

Creates NaN (Not a Number).

Follows PostgreSQL semantics: NaN == NaN is true.

pub const fn value(&self) -> i64

Returns the raw i64 value.

For normal values, this is actual_value * 10^scale. For special values, this returns the sentinel value.

pub const fn raw(&self) -> i64

Returns the raw i64 value (alias for columnar storage compatibility).

pub fn is_zero(&self) -> bool

Returns true if this value is zero.

pub fn is_negative(&self) -> bool

Returns true if this value is negative (excluding special values).

pub fn is_positive(&self) -> bool

Returns true if this value is positive (excluding special values).

pub fn is_pos_infinity(&self) -> bool

Returns true if this value is positive infinity.

pub fn is_neg_infinity(&self) -> bool

Returns true if this value is negative infinity.

pub fn is_infinity(&self) -> bool

Returns true if this value is positive or negative infinity.

pub fn is_nan(&self) -> bool

Returns true if this value is NaN (Not a Number).

pub fn is_special(&self) -> bool

Returns true if this is a special value (Infinity or NaN).

pub fn is_finite(&self) -> bool

Returns true if this is a finite number (not Infinity or NaN).

pub fn to_string_with_scale(&self, scale: i32) -> String

Formats the value as a decimal string using the given scale.

Arguments

• scale - The scale to use for formatting

Examples

use decimal_bytes::Decimal64NoScale;

let d = Decimal64NoScale::from_raw(12345);
assert_eq!(d.to_string_with_scale(2), "123.45");
assert_eq!(d.to_string_with_scale(3), "12.345");
assert_eq!(d.to_string_with_scale(0), "12345");

pub fn to_be_bytes(&self) -> [u8; 8]

Returns the 8-byte big-endian representation.

pub fn from_be_bytes(bytes: [u8; 8]) -> Self

Creates a Decimal64NoScale from big-endian bytes.

pub fn to_decimal(&self, scale: i32) -> Decimal

Converts to the variable-length Decimal type.

Note: This requires a scale to format correctly.

pub fn from_decimal(decimal: &Decimal, scale: i32) -> Result<Self, DecimalError>

Creates a Decimal64NoScale from a Decimal with the specified scale.

pub const fn min_value() -> Self

Returns the minimum finite value.

pub const fn max_value() -> Self

Returns the maximum finite value.

pub fn cmp_with_scale( &self, other: &Self, self_scale: i32, other_scale: i32, ) -> Ordering

Compares two values, normalizing scales if different.

This is needed when comparing values that might have been stored with different scales in different columns.

Trait Implementations

impl Clone for Decimal64NoScale

fn clone(&self) -> Decimal64NoScale

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Decimal64NoScale

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

Formats the value using the given formatter.

impl Default for Decimal64NoScale

fn default() -> Decimal64NoScale

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Decimal64NoScale

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Decimal64NoScale

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

Display without scale (shows raw value).

For formatted output, use to_string_with_scale().

impl From<i32> for Decimal64NoScale

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Decimal64NoScale

fn from(value: i64) -> Self

Converts to this type from the input type.

impl Hash for Decimal64NoScale

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 Ord for Decimal64NoScale

fn cmp(&self, other: &Self) -> Ordering

Compares values assuming same scale.

For cross-scale comparison, use cmp_with_scale().

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 for Decimal64NoScale

fn eq(&self, other: &Decimal64NoScale) -> 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 for Decimal64NoScale

fn partial_cmp(&self, other: &Self) -> 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 Serialize for Decimal64NoScale

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Decimal64NoScale

impl Eq for Decimal64NoScale

impl StructuralPartialEq for Decimal64NoScale