reifydb_core/value/encoded/
decimal.rs

1// Copyright (c) reifydb.com 2025
2// This file is licensed under the AGPL-3.0-or-later, see license.md file
3
4use std::ptr;
5
6use bigdecimal::BigDecimal as StdBigDecimal;
7use num_bigint::BigInt as StdBigInt;
8use reifydb_type::{Decimal, Type};
9
10use crate::value::encoded::{EncodedValues, EncodedValuesLayout};
11
12/// Decimal storage using dynamic section
13/// All decimals are stored in dynamic section with MSB=1 to store both mantissa
14/// and scale
15const MODE_DYNAMIC: u128 = 0x80000000000000000000000000000000;
16const MODE_MASK: u128 = 0x80000000000000000000000000000000;
17
18/// Bit masks for dynamic mode (lower 127 bits contain offset+length)
19const DYNAMIC_OFFSET_MASK: u128 = 0x0000000000000000FFFFFFFFFFFFFFFF; // 64 bits for offset
20const DYNAMIC_LENGTH_MASK: u128 = 0x7FFFFFFFFFFFFFFF0000000000000000; // 63 bits for length
21
22impl EncodedValuesLayout {
23	/// Set a Decimal value with 2-tier storage optimization
24	/// - Values that fit in i128: stored inline with MSB=0
25	/// - Large values: stored in dynamic section with MSB=1
26	pub fn set_decimal(&self, row: &mut EncodedValues, index: usize, value: &Decimal) {
27		let field = &self.fields[index];
28		debug_assert!(matches!(field.r#type, Type::Decimal { .. }));
29
30		// Get the mantissa and original scale from the BigDecimal
31		let (mantissa, original_scale) = value.inner().as_bigint_and_exponent();
32
33		// Always use dynamic storage to store both mantissa and scale
34		debug_assert!(!row.is_defined(index), "Decimal field {} already set", index);
35
36		// Serialize as scale (i64) + mantissa (variable bytes)
37		let scale_bytes = original_scale.to_le_bytes();
38		let digits_bytes = mantissa.to_signed_bytes_le();
39
40		let dynamic_offset = self.dynamic_section_size(row);
41		let total_size = 8 + digits_bytes.len(); // 8 bytes for scale + variable for mantissa
42
43		// Append to dynamic section: scale first, then mantissa
44		row.0.extend_from_slice(&scale_bytes);
45		row.0.extend_from_slice(&digits_bytes);
46
47		// Pack offset and length in lower 127 bits, set MSB=1
48		let offset_part = (dynamic_offset as u128) & DYNAMIC_OFFSET_MASK;
49		let length_part = ((total_size as u128) << 64) & DYNAMIC_LENGTH_MASK;
50		let packed = MODE_DYNAMIC | offset_part | length_part;
51
52		unsafe {
53			ptr::write_unaligned(
54				row.make_mut().as_mut_ptr().add(field.offset) as *mut u128,
55				packed.to_le(),
56			);
57		}
58		row.set_valid(index, true);
59	}
60
61	/// Get a Decimal value, detecting storage mode from MSB
62	pub fn get_decimal(&self, row: &EncodedValues, index: usize) -> Decimal {
63		let field = &self.fields[index];
64		debug_assert!(matches!(field.r#type, Type::Decimal { .. }));
65
66		let packed = unsafe { (row.as_ptr().add(field.offset) as *const u128).read_unaligned() };
67		let packed = u128::from_le(packed);
68
69		// Always expect dynamic storage (MSB=1)
70		debug_assert!(packed & MODE_MASK == MODE_DYNAMIC, "Expected dynamic storage");
71
72		// Extract offset and length
73		let offset = (packed & DYNAMIC_OFFSET_MASK) as usize;
74		let length = ((packed & DYNAMIC_LENGTH_MASK) >> 64) as usize;
75
76		let dynamic_start = self.dynamic_section_start();
77		let data_bytes = &row.as_slice()[dynamic_start + offset..dynamic_start + offset + length];
78
79		// Parse scale (first 8 bytes) and mantissa (remaining bytes)
80		let original_scale = i64::from_le_bytes(data_bytes[0..8].try_into().unwrap());
81		let mantissa = StdBigInt::from_signed_bytes_le(&data_bytes[8..]);
82
83		// Reconstruct the BigDecimal with original scale
84		let big_decimal = StdBigDecimal::new(mantissa, original_scale);
85
86		// Create our Decimal from the reconstructed BigDecimal
87		Decimal::from(big_decimal)
88	}
89
90	/// Try to get a Decimal value, returning None if undefined
91	pub fn try_get_decimal(&self, row: &EncodedValues, index: usize) -> Option<Decimal> {
92		if row.is_defined(index) {
93			Some(self.get_decimal(row, index))
94		} else {
95			None
96		}
97	}
98}
99
100#[cfg(test)]
101mod tests {
102	use std::str::FromStr;
103
104	use num_traits::Zero;
105	use reifydb_type::{Decimal, Type};
106
107	use crate::value::encoded::EncodedValuesLayout;
108
109	#[test]
110	fn test_compact_inline() {
111		let layout = EncodedValuesLayout::new(&[Type::Decimal]);
112		let mut row = layout.allocate();
113
114		// Test simple decimal
115		let decimal = Decimal::from_str("123.45").unwrap();
116		layout.set_decimal(&mut row, 0, &decimal);
117		assert!(row.is_defined(0));
118
119		let retrieved = layout.get_decimal(&row, 0);
120		assert_eq!(retrieved.to_string(), "123.45");
121
122		// Test negative decimal
123		let mut row2 = layout.allocate();
124		let negative = Decimal::from_str("-999.99").unwrap();
125		layout.set_decimal(&mut row2, 0, &negative);
126		assert_eq!(layout.get_decimal(&row2, 0).to_string(), "-999.99");
127	}
128
129	#[test]
130	fn test_compact_boundaries() {
131		// Test high precision decimal
132		let layout1 = EncodedValuesLayout::new(&[Type::Decimal]);
133		let mut row1 = layout1.allocate();
134		let high_precision = Decimal::from_str("1.0000000000000000000000000000001").unwrap();
135		layout1.set_decimal(&mut row1, 0, &high_precision);
136		let retrieved = layout1.get_decimal(&row1, 0);
137		assert_eq!(retrieved.to_string(), "1.0000000000000000000000000000001");
138
139		// Test large integer (scale 0)
140		let layout2 = EncodedValuesLayout::new(&[Type::Decimal]);
141		let mut row2 = layout2.allocate();
142		let large_int = Decimal::from_str("100000000000000000000000000000000").unwrap();
143		layout2.set_decimal(&mut row2, 0, &large_int);
144		assert_eq!(layout2.get_decimal(&row2, 0).to_string(), "100000000000000000000000000000000");
145	}
146
147	#[test]
148	fn test_extended_i128() {
149		let layout = EncodedValuesLayout::new(&[Type::Decimal]);
150		let mut row = layout.allocate();
151
152		// Value that needs i128 mantissa
153		let large = Decimal::from_str("999999999999999999999.123456789").unwrap();
154		layout.set_decimal(&mut row, 0, &large);
155		assert!(row.is_defined(0));
156
157		let retrieved = layout.get_decimal(&row, 0);
158		assert_eq!(retrieved.to_string(), "999999999999999999999.123456789");
159	}
160
161	#[test]
162	fn test_dynamic_storage() {
163		// Use a smaller test that will still trigger dynamic storage
164		// due to large mantissa
165		let layout = EncodedValuesLayout::new(&[Type::Decimal]);
166		let mut row = layout.allocate();
167
168		// Create a value with large precision that will exceed i128
169		// when scaled
170		let huge = Decimal::from_str("99999999999999999999999999999.123456789").unwrap();
171
172		layout.set_decimal(&mut row, 0, &huge);
173		assert!(row.is_defined(0));
174
175		let retrieved = layout.get_decimal(&row, 0);
176		assert_eq!(retrieved.to_string(), "99999999999999999999999999999.123456789");
177	}
178
179	#[test]
180	fn test_zero() {
181		let layout = EncodedValuesLayout::new(&[Type::Decimal]);
182		let mut row = layout.allocate();
183
184		let zero = Decimal::from_str("0.0").unwrap();
185		layout.set_decimal(&mut row, 0, &zero);
186		assert!(row.is_defined(0));
187
188		let retrieved = layout.get_decimal(&row, 0);
189		assert!(retrieved.inner().is_zero());
190	}
191
192	#[test]
193	fn test_currency_values() {
194		let layout = EncodedValuesLayout::new(&[Type::Decimal]);
195
196		// Test typical currency value (2 decimal places)
197		let mut row1 = layout.allocate();
198		let price = Decimal::from_str("19.99").unwrap();
199		layout.set_decimal(&mut row1, 0, &price);
200		assert_eq!(layout.get_decimal(&row1, 0).to_string(), "19.99");
201
202		// Test large currency value
203		let mut row2 = layout.allocate();
204		let large_price = Decimal::from_str("999999999.99").unwrap();
205		layout.set_decimal(&mut row2, 0, &large_price);
206		assert_eq!(layout.get_decimal(&row2, 0).to_string(), "999999999.99");
207
208		// Test small fraction
209		let mut row3 = layout.allocate();
210		let fraction = Decimal::from_str("0.00000001").unwrap();
211		layout.set_decimal(&mut row3, 0, &fraction);
212		assert_eq!(layout.get_decimal(&row3, 0), fraction);
213	}
214
215	#[test]
216	fn test_scientific_notation() {
217		let layout = EncodedValuesLayout::new(&[Type::Decimal]);
218		let mut row = layout.allocate();
219
220		let scientific = Decimal::from_str("1.23456e10").unwrap();
221		layout.set_decimal(&mut row, 0, &scientific);
222
223		let retrieved = layout.get_decimal(&row, 0);
224		assert_eq!(retrieved.to_string(), "12345600000");
225	}
226
227	#[test]
228	fn test_try_get() {
229		let layout = EncodedValuesLayout::new(&[Type::Decimal]);
230		let mut row = layout.allocate();
231
232		// Undefined initially
233		assert_eq!(layout.try_get_decimal(&row, 0), None);
234
235		// Set value
236		let value = Decimal::from_str("42.42").unwrap();
237		layout.set_decimal(&mut row, 0, &value);
238
239		let retrieved = layout.try_get_decimal(&row, 0);
240		assert!(retrieved.is_some());
241		assert_eq!(retrieved.unwrap().to_string(), "42.42");
242	}
243
244	#[test]
245	fn test_clone_on_write() {
246		let layout = EncodedValuesLayout::new(&[Type::Decimal]);
247		let row1 = layout.allocate();
248		let mut row2 = row1.clone();
249
250		let value = Decimal::from_str("3.14159").unwrap();
251		layout.set_decimal(&mut row2, 0, &value);
252
253		assert!(!row1.is_defined(0));
254		assert!(row2.is_defined(0));
255		assert_ne!(row1.as_ptr(), row2.as_ptr());
256		assert_eq!(layout.get_decimal(&row2, 0).to_string(), "3.14159");
257	}
258
259	#[test]
260	fn test_mixed_with_other_types() {
261		let layout = EncodedValuesLayout::new(&[
262			Type::Boolean,
263			Type::Decimal,
264			Type::Utf8,
265			Type::Decimal,
266			Type::Int4,
267		]);
268		let mut row = layout.allocate();
269
270		layout.set_bool(&mut row, 0, true);
271
272		let small_decimal = Decimal::from_str("99.99").unwrap();
273		layout.set_decimal(&mut row, 1, &small_decimal);
274
275		layout.set_utf8(&mut row, 2, "test");
276
277		let large_decimal = Decimal::from_str("123456789.987654321").unwrap();
278		layout.set_decimal(&mut row, 3, &large_decimal);
279
280		layout.set_i32(&mut row, 4, -42);
281
282		assert_eq!(layout.get_bool(&row, 0), true);
283		assert_eq!(layout.get_decimal(&row, 1).to_string(), "99.99");
284		assert_eq!(layout.get_utf8(&row, 2), "test");
285		assert_eq!(layout.get_decimal(&row, 3).to_string(), "123456789.987654321");
286		assert_eq!(layout.get_i32(&row, 4), -42);
287	}
288
289	#[test]
290	fn test_negative_values() {
291		// Small negative (compact inline) - needs scale 2
292		let layout1 = EncodedValuesLayout::new(&[Type::Decimal]);
293
294		let mut row1 = layout1.allocate();
295		let small_neg = Decimal::from_str("-0.01").unwrap();
296		layout1.set_decimal(&mut row1, 0, &small_neg);
297		assert_eq!(layout1.get_decimal(&row1, 0).to_string(), "-0.01");
298
299		// Large negative (extended i128) - needs scale 3
300		let layout2 = EncodedValuesLayout::new(&[Type::Decimal]);
301		let mut row2 = layout2.allocate();
302		let large_neg = Decimal::from_str("-999999999999999999.999").unwrap();
303		layout2.set_decimal(&mut row2, 0, &large_neg);
304		assert_eq!(layout2.get_decimal(&row2, 0).to_string(), "-999999999999999999.999");
305
306		// Huge negative (dynamic) - needs scale 9
307		let layout3 = EncodedValuesLayout::new(&[Type::Decimal]);
308		let mut row3 = layout3.allocate();
309		let huge_neg = Decimal::from_str("-99999999999999999999999999999.999999999").unwrap();
310		layout3.set_decimal(&mut row3, 0, &huge_neg);
311		assert_eq!(layout3.get_decimal(&row3, 0).to_string(), "-99999999999999999999999999999.999999999");
312	}
313}
reifydb_core/value/encoded/decimal.rs

reifydb_core/value/encoded/
decimal.rs
