/Users/andrewlamb/Software/arrow-rs/arrow-data/src/decimal.rs

Line	Count	Source
1		// Licensed to the Apache Software Foundation (ASF) under one
2		// or more contributor license agreements. See the NOTICE file
3		// distributed with this work for additional information
4		// regarding copyright ownership. The ASF licenses this file
5		// to you under the Apache License, Version 2.0 (the
6		// "License"); you may not use this file except in compliance
7		// with the License. You may obtain a copy of the License at
8		//
9		// http://www.apache.org/licenses/LICENSE-2.0
10		//
11		// Unless required by applicable law or agreed to in writing,
12		// software distributed under the License is distributed on an
13		// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14		// KIND, either express or implied. See the License for the
15		// specific language governing permissions and limitations
16		// under the License.
17
18		//! Maximum and minimum values for [`Decimal256`], [`Decimal128`], [`Decimal64`] and [`Decimal32`].
19		//!
20		//! Also provides functions to validate if a given decimal value is within
21		//! the valid range of the decimal type.
22		//!
23		//! [`Decimal32`]: arrow_schema::DataType::Decimal32
24		//! [`Decimal64`]: arrow_schema::DataType::Decimal64
25		//! [`Decimal128`]: arrow_schema::DataType::Decimal128
26		//! [`Decimal256`]: arrow_schema::DataType::Decimal256
27		use arrow_buffer::i256;
28		use arrow_schema::ArrowError;
29
30		pub use arrow_schema::{
31		DECIMAL128_MAX_PRECISION, DECIMAL128_MAX_SCALE, DECIMAL256_MAX_PRECISION, DECIMAL256_MAX_SCALE,
32		DECIMAL32_DEFAULT_SCALE, DECIMAL32_MAX_PRECISION, DECIMAL32_MAX_SCALE, DECIMAL64_DEFAULT_SCALE,
33		DECIMAL64_MAX_PRECISION, DECIMAL64_MAX_SCALE, DECIMAL_DEFAULT_SCALE,
34		};
35
36		/// `MAX_DECIMAL256_FOR_EACH_PRECISION[p]` holds the maximum [`i256`] value that can
37		/// be stored in a [`Decimal256`] value of precision `p`.
38		///
39		/// # Notes
40		///
41		/// Each element is the max value of signed 256-bit integer for the specified
42		/// precision which is encoded to the 32-byte width format of little-endian.
43		///
44		/// The first element is unused and is inserted so that we can look up using
45		/// precision as the index without the need to subtract 1 first.
46		///
47		/// # Example
48		/// ```
49		/// # use arrow_buffer::i256;
50		/// # use arrow_data::decimal::MAX_DECIMAL256_FOR_EACH_PRECISION;
51		/// assert_eq!(MAX_DECIMAL256_FOR_EACH_PRECISION[3], i256::from(999));
52		/// ```
53		///
54		/// [`Decimal256`]: arrow_schema::DataType::Decimal256
55		/// [`i256`]: arrow_buffer::i256
56		pub const MAX_DECIMAL256_FOR_EACH_PRECISION: [i256; 77] = [
57		i256::from_i128(0_i128), // unused first element
58		i256::from_le_bytes([
59		9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
60		0, 0,
61		]),
62		i256::from_le_bytes([
63		99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
64		0, 0,
65		]),
66		i256::from_le_bytes([
67		231, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
68		0, 0,
69		]),
70		i256::from_le_bytes([
71		15, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72		0, 0,
73		]),
74		i256::from_le_bytes([
75		159, 134, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
76		0, 0, 0,
77		]),
78		i256::from_le_bytes([
79		63, 66, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
80		0, 0, 0,
81		]),
82		i256::from_le_bytes([
83		127, 150, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
84		0, 0, 0, 0,
85		]),
86		i256::from_le_bytes([
87		255, 224, 245, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
88		0, 0, 0, 0,
89		]),
90		i256::from_le_bytes([
91		255, 201, 154, 59, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
92		0, 0, 0, 0,
93		]),
94		i256::from_le_bytes([
95		255, 227, 11, 84, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
96		0, 0, 0, 0,
97		]),
98		i256::from_le_bytes([
99		255, 231, 118, 72, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
100		0, 0, 0, 0,
101		]),
102		i256::from_le_bytes([
103		255, 15, 165, 212, 232, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
104		0, 0, 0, 0, 0,
105		]),
106		i256::from_le_bytes([
107		255, 159, 114, 78, 24, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
108		0, 0, 0, 0,
109		]),
110		i256::from_le_bytes([
111		255, 63, 122, 16, 243, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
112		0, 0, 0, 0, 0,
113		]),
114		i256::from_le_bytes([
115		255, 127, 198, 164, 126, 141, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
116		0, 0, 0, 0, 0, 0,
117		]),
118		i256::from_le_bytes([
119		255, 255, 192, 111, 242, 134, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
120		0, 0, 0, 0, 0, 0,
121		]),
122		i256::from_le_bytes([
123		255, 255, 137, 93, 120, 69, 99, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
124		0, 0, 0, 0, 0,
125		]),
126		i256::from_le_bytes([
127		255, 255, 99, 167, 179, 182, 224, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
128		0, 0, 0, 0, 0, 0,
129		]),
130		i256::from_le_bytes([
131		255, 255, 231, 137, 4, 35, 199, 138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
132		0, 0, 0, 0, 0, 0,
133		]),
134		i256::from_le_bytes([
135		255, 255, 15, 99, 45, 94, 199, 107, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
136		0, 0, 0, 0, 0, 0,
137		]),
138		i256::from_le_bytes([
139		255, 255, 159, 222, 197, 173, 201, 53, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
140		0, 0, 0, 0, 0, 0, 0,
141		]),
142		i256::from_le_bytes([
143		255, 255, 63, 178, 186, 201, 224, 25, 30, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
144		0, 0, 0, 0, 0, 0, 0,
145		]),
146		i256::from_le_bytes([
147		255, 255, 127, 246, 74, 225, 199, 2, 45, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
148		0, 0, 0, 0, 0, 0, 0,
149		]),
150		i256::from_le_bytes([
151		255, 255, 255, 160, 237, 204, 206, 27, 194, 211, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
152		0, 0, 0, 0, 0, 0, 0, 0,
153		]),
154		i256::from_le_bytes([
155		255, 255, 255, 73, 72, 1, 20, 22, 149, 69, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
156		0, 0, 0, 0, 0, 0,
157		]),
158		i256::from_le_bytes([
159		255, 255, 255, 227, 210, 12, 200, 220, 210, 183, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
160		0, 0, 0, 0, 0, 0, 0, 0,
161		]),
162		i256::from_le_bytes([
163		255, 255, 255, 231, 60, 128, 208, 159, 60, 46, 59, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
164		0, 0, 0, 0, 0, 0, 0, 0,
165		]),
166		i256::from_le_bytes([
167		255, 255, 255, 15, 97, 2, 37, 62, 94, 206, 79, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
168		0, 0, 0, 0, 0, 0, 0,
169		]),
170		i256::from_le_bytes([
171		255, 255, 255, 159, 202, 23, 114, 109, 174, 15, 30, 67, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
172		0, 0, 0, 0, 0, 0, 0, 0,
173		]),
174		i256::from_le_bytes([
175		255, 255, 255, 63, 234, 237, 116, 70, 208, 156, 44, 159, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
176		0, 0, 0, 0, 0, 0, 0, 0, 0,
177		]),
178		i256::from_le_bytes([
179		255, 255, 255, 127, 38, 75, 145, 192, 34, 32, 190, 55, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
180		0, 0, 0, 0, 0, 0, 0, 0, 0,
181		]),
182		i256::from_le_bytes([
183		255, 255, 255, 255, 128, 239, 172, 133, 91, 65, 109, 45, 238, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0,
184		0, 0, 0, 0, 0, 0, 0, 0, 0,
185		]),
186		i256::from_le_bytes([
187		255, 255, 255, 255, 9, 91, 193, 56, 147, 141, 68, 198, 77, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
188		0, 0, 0, 0, 0, 0, 0, 0, 0,
189		]),
190		i256::from_le_bytes([
191		255, 255, 255, 255, 99, 142, 141, 55, 192, 135, 173, 190, 9, 237, 1, 0, 0, 0, 0, 0, 0, 0,
192		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
193		]),
194		i256::from_le_bytes([
195		255, 255, 255, 255, 231, 143, 135, 43, 130, 77, 199, 114, 97, 66, 19, 0, 0, 0, 0, 0, 0, 0,
196		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
197		]),
198		i256::from_le_bytes([
199		255, 255, 255, 255, 15, 159, 75, 179, 21, 7, 201, 123, 206, 151, 192, 0, 0, 0, 0, 0, 0, 0,
200		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
201		]),
202		i256::from_le_bytes([
203		255, 255, 255, 255, 159, 54, 244, 0, 217, 70, 218, 213, 16, 238, 133, 7, 0, 0, 0, 0, 0, 0,
204		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
205		]),
206		i256::from_le_bytes([
207		255, 255, 255, 255, 63, 34, 138, 9, 122, 196, 134, 90, 168, 76, 59, 75, 0, 0, 0, 0, 0, 0,
208		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
209		]),
210		i256::from_le_bytes([
211		255, 255, 255, 255, 127, 86, 101, 95, 196, 172, 67, 137, 147, 254, 80, 240, 2, 0, 0, 0, 0,
212		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
213		]),
214		i256::from_le_bytes([
215		255, 255, 255, 255, 255, 96, 245, 185, 171, 191, 164, 92, 195, 241, 41, 99, 29, 0, 0, 0, 0,
216		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
217		]),
218		i256::from_le_bytes([
219		255, 255, 255, 255, 255, 201, 149, 67, 181, 124, 111, 158, 161, 113, 163, 223, 37, 1, 0, 0,
220		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
221		]),
222		i256::from_le_bytes([
223		255, 255, 255, 255, 255, 227, 217, 163, 20, 223, 90, 48, 80, 112, 98, 188, 122, 11, 0, 0,
224		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
225		]),
226		i256::from_le_bytes([
227		255, 255, 255, 255, 255, 231, 130, 102, 206, 182, 140, 227, 33, 99, 216, 91, 203, 114, 0,
228		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
229		]),
230		i256::from_le_bytes([
231		255, 255, 255, 255, 255, 15, 29, 1, 16, 36, 127, 227, 82, 223, 115, 150, 241, 123, 4, 0, 0,
232		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
233		]),
234		i256::from_le_bytes([
235		255, 255, 255, 255, 255, 159, 34, 11, 160, 104, 247, 226, 60, 185, 134, 224, 111, 215, 44,
236		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
237		]),
238		i256::from_le_bytes([
239		255, 255, 255, 255, 255, 63, 90, 111, 64, 22, 170, 221, 96, 60, 67, 197, 94, 106, 192, 1,
240		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241		]),
242		i256::from_le_bytes([
243		255, 255, 255, 255, 255, 127, 134, 89, 132, 222, 164, 168, 200, 91, 160, 180, 179, 39, 132,
244		17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245		]),
246		i256::from_le_bytes([
247		255, 255, 255, 255, 255, 255, 64, 127, 43, 177, 112, 150, 214, 149, 67, 14, 5, 141, 41,
248		175, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249		]),
250		i256::from_le_bytes([
251		255, 255, 255, 255, 255, 255, 137, 248, 178, 235, 102, 224, 97, 218, 163, 142, 50, 130,
252		159, 215, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253		]),
254		i256::from_le_bytes([
255		255, 255, 255, 255, 255, 255, 99, 181, 253, 52, 5, 196, 210, 135, 102, 146, 249, 21, 59,
256		108, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
257		]),
258		i256::from_le_bytes([
259		255, 255, 255, 255, 255, 255, 231, 21, 233, 17, 52, 168, 59, 78, 1, 184, 191, 219, 78, 58,
260		172, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
261		]),
262		i256::from_le_bytes([
263		255, 255, 255, 255, 255, 255, 15, 219, 26, 179, 8, 146, 84, 14, 13, 48, 125, 149, 20, 71,
264		186, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
265		]),
266		i256::from_le_bytes([
267		255, 255, 255, 255, 255, 255, 159, 142, 12, 255, 86, 180, 77, 143, 130, 224, 227, 214, 205,
268		198, 70, 11, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
269		]),
270		i256::from_le_bytes([
271		255, 255, 255, 255, 255, 255, 63, 146, 125, 246, 101, 11, 9, 153, 25, 197, 230, 100, 10,
272		196, 195, 112, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
273		]),
274		i256::from_le_bytes([
275		255, 255, 255, 255, 255, 255, 127, 182, 231, 160, 251, 113, 90, 250, 255, 178, 3, 241, 103,
276		168, 165, 103, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0,
277		]),
278		i256::from_le_bytes([
279		255, 255, 255, 255, 255, 255, 255, 32, 13, 73, 212, 115, 136, 199, 255, 253, 36, 106, 15,
280		148, 120, 12, 20, 4, 0, 0, 0, 0, 0, 0, 0, 0,
281		]),
282		i256::from_le_bytes([
283		255, 255, 255, 255, 255, 255, 255, 73, 131, 218, 74, 134, 84, 203, 253, 235, 113, 37, 154,
284		200, 181, 124, 200, 40, 0, 0, 0, 0, 0, 0, 0, 0,
285		]),
286		i256::from_le_bytes([
287		255, 255, 255, 255, 255, 255, 255, 227, 32, 137, 236, 62, 77, 241, 233, 55, 115, 118, 5,
288		214, 25, 223, 212, 151, 1, 0, 0, 0, 0, 0, 0, 0,
289		]),
290		i256::from_le_bytes([
291		255, 255, 255, 255, 255, 255, 255, 231, 72, 91, 61, 117, 4, 109, 35, 47, 128, 160, 54, 92,
292		2, 183, 80, 238, 15, 0, 0, 0, 0, 0, 0, 0,
293		]),
294		i256::from_le_bytes([
295		255, 255, 255, 255, 255, 255, 255, 15, 217, 144, 101, 148, 44, 66, 98, 215, 1, 69, 34, 154,
296		23, 38, 39, 79, 159, 0, 0, 0, 0, 0, 0, 0,
297		]),
298		i256::from_le_bytes([
299		255, 255, 255, 255, 255, 255, 255, 159, 122, 168, 247, 203, 189, 149, 214, 105, 18, 178,
300		86, 5, 236, 124, 135, 23, 57, 6, 0, 0, 0, 0, 0, 0,
301		]),
302		i256::from_le_bytes([
303		255, 255, 255, 255, 255, 255, 255, 63, 202, 148, 172, 247, 105, 217, 97, 34, 184, 244, 98,
304		53, 56, 225, 74, 235, 58, 62, 0, 0, 0, 0, 0, 0,
305		]),
306		i256::from_le_bytes([
307		255, 255, 255, 255, 255, 255, 255, 127, 230, 207, 189, 172, 35, 126, 210, 87, 49, 143, 221,
308		21, 50, 204, 236, 48, 77, 110, 2, 0, 0, 0, 0, 0,
309		]),
310		i256::from_le_bytes([
311		255, 255, 255, 255, 255, 255, 255, 255, 0, 31, 106, 191, 100, 237, 56, 110, 237, 151, 167,
312		218, 244, 249, 63, 233, 3, 79, 24, 0, 0, 0, 0, 0,
313		]),
314		i256::from_le_bytes([
315		255, 255, 255, 255, 255, 255, 255, 255, 9, 54, 37, 122, 239, 69, 57, 78, 70, 239, 139, 138,
316		144, 195, 127, 28, 39, 22, 243, 0, 0, 0, 0, 0,
317		]),
318		i256::from_le_bytes([
319		255, 255, 255, 255, 255, 255, 255, 255, 99, 28, 116, 197, 90, 187, 60, 14, 191, 88, 119,
320		105, 165, 163, 253, 28, 135, 221, 126, 9, 0, 0, 0, 0,
321		]),
322		i256::from_le_bytes([
323		255, 255, 255, 255, 255, 255, 255, 255, 231, 27, 137, 182, 139, 81, 95, 142, 118, 119, 169,
324		30, 118, 100, 232, 33, 71, 167, 244, 94, 0, 0, 0, 0,
325		]),
326		i256::from_le_bytes([
327		255, 255, 255, 255, 255, 255, 255, 255, 15, 23, 91, 33, 117, 47, 185, 143, 161, 170, 158,
328		50, 157, 236, 19, 83, 199, 136, 142, 181, 3, 0, 0, 0,
329		]),
330		i256::from_le_bytes([
331		255, 255, 255, 255, 255, 255, 255, 255, 159, 230, 142, 77, 147, 218, 59, 157, 79, 170, 50,
332		250, 35, 62, 199, 62, 201, 87, 145, 23, 37, 0, 0, 0,
333		]),
334		i256::from_le_bytes([
335		255, 255, 255, 255, 255, 255, 255, 255, 63, 2, 149, 7, 193, 137, 86, 36, 28, 167, 250, 197,
336		103, 109, 200, 115, 220, 109, 173, 235, 114, 1, 0, 0,
337		]),
338		i256::from_le_bytes([
339		255, 255, 255, 255, 255, 255, 255, 255, 127, 22, 210, 75, 138, 97, 97, 107, 25, 135, 202,
340		187, 13, 70, 212, 133, 156, 74, 198, 52, 125, 14, 0, 0,
341		]),
342		i256::from_le_bytes([
343		255, 255, 255, 255, 255, 255, 255, 255, 255, 224, 52, 246, 102, 207, 205, 49, 254, 70, 233,
344		85, 137, 188, 74, 58, 29, 234, 190, 15, 228, 144, 0, 0,
345		]),
346		i256::from_le_bytes([
347		255, 255, 255, 255, 255, 255, 255, 255, 255, 201, 16, 158, 5, 26, 10, 242, 237, 197, 28,
348		91, 93, 93, 235, 70, 36, 37, 117, 157, 232, 168, 5, 0,
349		]),
350		i256::from_le_bytes([
351		255, 255, 255, 255, 255, 255, 255, 255, 255, 227, 167, 44, 56, 4, 101, 116, 75, 187, 31,
352		143, 165, 165, 49, 197, 106, 115, 147, 38, 22, 153, 56, 0,
353		]),
354		i256::from_le_bytes([
355		255, 255, 255, 255, 255, 255, 255, 255, 255, 231, 142, 190, 49, 42, 242, 139, 242, 80, 61,
356		151, 119, 120, 240, 179, 43, 130, 194, 129, 221, 250, 53, 2,
357		]),
358		i256::from_le_bytes([
359		255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 149, 113, 241, 165, 117, 119, 121, 41,
360		101, 232, 171, 180, 100, 7, 181, 21, 153, 17, 167, 204, 27, 22,
361		]),
362		];
363
364		/// `MIN_DECIMAL256_FOR_EACH_PRECISION[p]` holds the minimum [`i256`] value that can
365		/// be stored in a [`Decimal256`] value of precision `p`.
366		///
367		/// # Notes
368		///
369		/// Each element is the min value of signed 256-bit integer for the specified precision which
370		/// is encoded to the 76-byte width format of little-endian.
371		///
372		/// The first element is unused and is inserted so that we can look up using
373		/// precision as the index without the need to subtract 1 first.
374		/// # Example
375		/// ```
376		/// # use arrow_buffer::i256;
377		/// # use arrow_data::decimal::MIN_DECIMAL256_FOR_EACH_PRECISION;
378		/// assert_eq!(MIN_DECIMAL256_FOR_EACH_PRECISION[3], i256::from(-999));
379		/// ```
380		///
381		/// [`i256`]: arrow_buffer::i256
382		/// [`Decimal256`]: arrow_schema::DataType::Decimal256
383		pub const MIN_DECIMAL256_FOR_EACH_PRECISION: [i256; 77] = [
384		i256::from_i128(0_i128), // unused first element
385		i256::from_le_bytes([
386		247, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
387		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
388		]),
389		i256::from_le_bytes([
390		157, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
391		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
392		]),
393		i256::from_le_bytes([
394		25, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
395		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
396		]),
397		i256::from_le_bytes([
398		241, 216, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
399		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
400		]),
401		i256::from_le_bytes([
402		97, 121, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
403		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
404		]),
405		i256::from_le_bytes([
406		193, 189, 240, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
407		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
408		]),
409		i256::from_le_bytes([
410		129, 105, 103, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
411		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
412		]),
413		i256::from_le_bytes([
414		1, 31, 10, 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
415		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
416		]),
417		i256::from_le_bytes([
418		1, 54, 101, 196, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
419		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
420		]),
421		i256::from_le_bytes([
422		1, 28, 244, 171, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
423		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
424		]),
425		i256::from_le_bytes([
426		1, 24, 137, 183, 232, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
427		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
428		]),
429		i256::from_le_bytes([
430		1, 240, 90, 43, 23, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
431		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
432		]),
433		i256::from_le_bytes([
434		1, 96, 141, 177, 231, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
435		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
436		]),
437		i256::from_le_bytes([
438		1, 192, 133, 239, 12, 165, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
439		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
440		]),
441		i256::from_le_bytes([
442		1, 128, 57, 91, 129, 114, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
443		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
444		]),
445		i256::from_le_bytes([
446		1, 0, 63, 144, 13, 121, 220, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
447		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
448		]),
449		i256::from_le_bytes([
450		1, 0, 118, 162, 135, 186, 156, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
451		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
452		]),
453		i256::from_le_bytes([
454		1, 0, 156, 88, 76, 73, 31, 242, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
455		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
456		]),
457		i256::from_le_bytes([
458		1, 0, 24, 118, 251, 220, 56, 117, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
459		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
460		]),
461		i256::from_le_bytes([
462		1, 0, 240, 156, 210, 161, 56, 148, 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
463		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
464		]),
465		i256::from_le_bytes([
466		1, 0, 96, 33, 58, 82, 54, 202, 201, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
467		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
468		]),
469		i256::from_le_bytes([
470		1, 0, 192, 77, 69, 54, 31, 230, 225, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
471		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
472		]),
473		i256::from_le_bytes([
474		1, 0, 128, 9, 181, 30, 56, 253, 210, 234, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
475		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
476		]),
477		i256::from_le_bytes([
478		1, 0, 0, 95, 18, 51, 49, 228, 61, 44, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
479		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
480		]),
481		i256::from_le_bytes([
482		1, 0, 0, 182, 183, 254, 235, 233, 106, 186, 247, 255, 255, 255, 255, 255, 255, 255, 255,
483		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
484		]),
485		i256::from_le_bytes([
486		1, 0, 0, 28, 45, 243, 55, 35, 45, 72, 173, 255, 255, 255, 255, 255, 255, 255, 255, 255,
487		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
488		]),
489		i256::from_le_bytes([
490		1, 0, 0, 24, 195, 127, 47, 96, 195, 209, 196, 252, 255, 255, 255, 255, 255, 255, 255, 255,
491		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
492		]),
493		i256::from_le_bytes([
494		1, 0, 0, 240, 158, 253, 218, 193, 161, 49, 176, 223, 255, 255, 255, 255, 255, 255, 255,
495		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
496		]),
497		i256::from_le_bytes([
498		1, 0, 0, 96, 53, 232, 141, 146, 81, 240, 225, 188, 254, 255, 255, 255, 255, 255, 255, 255,
499		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
500		]),
501		i256::from_le_bytes([
502		1, 0, 0, 192, 21, 18, 139, 185, 47, 99, 211, 96, 243, 255, 255, 255, 255, 255, 255, 255,
503		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
504		]),
505		i256::from_le_bytes([
506		1, 0, 0, 128, 217, 180, 110, 63, 221, 223, 65, 200, 129, 255, 255, 255, 255, 255, 255, 255,
507		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
508		]),
509		i256::from_le_bytes([
510		1, 0, 0, 0, 127, 16, 83, 122, 164, 190, 146, 210, 17, 251, 255, 255, 255, 255, 255, 255,
511		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
512		]),
513		i256::from_le_bytes([
514		1, 0, 0, 0, 246, 164, 62, 199, 108, 114, 187, 57, 178, 206, 255, 255, 255, 255, 255, 255,
515		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
516		]),
517		i256::from_le_bytes([
518		1, 0, 0, 0, 156, 113, 114, 200, 63, 120, 82, 65, 246, 18, 254, 255, 255, 255, 255, 255,
519		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
520		]),
521		i256::from_le_bytes([
522		1, 0, 0, 0, 24, 112, 120, 212, 125, 178, 56, 141, 158, 189, 236, 255, 255, 255, 255, 255,
523		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
524		]),
525		i256::from_le_bytes([
526		1, 0, 0, 0, 240, 96, 180, 76, 234, 248, 54, 132, 49, 104, 63, 255, 255, 255, 255, 255, 255,
527		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
528		]),
529		i256::from_le_bytes([
530		1, 0, 0, 0, 96, 201, 11, 255, 38, 185, 37, 42, 239, 17, 122, 248, 255, 255, 255, 255, 255,
531		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
532		]),
533		i256::from_le_bytes([
534		1, 0, 0, 0, 192, 221, 117, 246, 133, 59, 121, 165, 87, 179, 196, 180, 255, 255, 255, 255,
535		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
536		]),
537		i256::from_le_bytes([
538		1, 0, 0, 0, 128, 169, 154, 160, 59, 83, 188, 118, 108, 1, 175, 15, 253, 255, 255, 255, 255,
539		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
540		]),
541		i256::from_le_bytes([
542		1, 0, 0, 0, 0, 159, 10, 70, 84, 64, 91, 163, 60, 14, 214, 156, 226, 255, 255, 255, 255,
543		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
544		]),
545		i256::from_le_bytes([
546		1, 0, 0, 0, 0, 54, 106, 188, 74, 131, 144, 97, 94, 142, 92, 32, 218, 254, 255, 255, 255,
547		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
548		]),
549		i256::from_le_bytes([
550		1, 0, 0, 0, 0, 28, 38, 92, 235, 32, 165, 207, 175, 143, 157, 67, 133, 244, 255, 255, 255,
551		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
552		]),
553		i256::from_le_bytes([
554		1, 0, 0, 0, 0, 24, 125, 153, 49, 73, 115, 28, 222, 156, 39, 164, 52, 141, 255, 255, 255,
555		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
556		]),
557		i256::from_le_bytes([
558		1, 0, 0, 0, 0, 240, 226, 254, 239, 219, 128, 28, 173, 32, 140, 105, 14, 132, 251, 255, 255,
559		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
560		]),
561		i256::from_le_bytes([
562		1, 0, 0, 0, 0, 96, 221, 244, 95, 151, 8, 29, 195, 70, 121, 31, 144, 40, 211, 255, 255, 255,
563		255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
564		]),
565		i256::from_le_bytes([
566		1, 0, 0, 0, 0, 192, 165, 144, 191, 233, 85, 34, 159, 195, 188, 58, 161, 149, 63, 254, 255,
567		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
568		]),
569		i256::from_le_bytes([
570		1, 0, 0, 0, 0, 128, 121, 166, 123, 33, 91, 87, 55, 164, 95, 75, 76, 216, 123, 238, 255,
571		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
572		]),
573		i256::from_le_bytes([
574		1, 0, 0, 0, 0, 0, 191, 128, 212, 78, 143, 105, 41, 106, 188, 241, 250, 114, 214, 80, 255,
575		255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
576		]),
577		i256::from_le_bytes([
578		1, 0, 0, 0, 0, 0, 118, 7, 77, 20, 153, 31, 158, 37, 92, 113, 205, 125, 96, 40, 249, 255,
579		255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
580		]),
581		i256::from_le_bytes([
582		1, 0, 0, 0, 0, 0, 156, 74, 2, 203, 250, 59, 45, 120, 153, 109, 6, 234, 196, 147, 187, 255,
583		255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
584		]),
585		i256::from_le_bytes([
586		1, 0, 0, 0, 0, 0, 24, 234, 22, 238, 203, 87, 196, 177, 254, 71, 64, 36, 177, 197, 83, 253,
587		255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
588		]),
589		i256::from_le_bytes([
590		1, 0, 0, 0, 0, 0, 240, 36, 229, 76, 247, 109, 171, 241, 242, 207, 130, 106, 235, 184, 69,
591		229, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
592		]),
593		i256::from_le_bytes([
594		1, 0, 0, 0, 0, 0, 96, 113, 243, 0, 169, 75, 178, 112, 125, 31, 28, 41, 50, 57, 185, 244,
595		254, 255, 255, 255, 255, 255, 255, 255, 255, 255,
596		]),
597		i256::from_le_bytes([
598		1, 0, 0, 0, 0, 0, 192, 109, 130, 9, 154, 244, 246, 102, 230, 58, 25, 155, 245, 59, 60, 143,
599		245, 255, 255, 255, 255, 255, 255, 255, 255, 255,
600		]),
601		i256::from_le_bytes([
602		1, 0, 0, 0, 0, 0, 128, 73, 24, 95, 4, 142, 165, 5, 0, 77, 252, 14, 152, 87, 90, 152, 151,
603		255, 255, 255, 255, 255, 255, 255, 255, 255,
604		]),
605		i256::from_le_bytes([
606		1, 0, 0, 0, 0, 0, 0, 223, 242, 182, 43, 140, 119, 56, 0, 2, 219, 149, 240, 107, 135, 243,
607		235, 251, 255, 255, 255, 255, 255, 255, 255, 255,
608		]),
609		i256::from_le_bytes([
610		1, 0, 0, 0, 0, 0, 0, 182, 124, 37, 181, 121, 171, 52, 2, 20, 142, 218, 101, 55, 74, 131,
611		55, 215, 255, 255, 255, 255, 255, 255, 255, 255,
612		]),
613		i256::from_le_bytes([
614		1, 0, 0, 0, 0, 0, 0, 28, 223, 118, 19, 193, 178, 14, 22, 200, 140, 137, 250, 41, 230, 32,
615		43, 104, 254, 255, 255, 255, 255, 255, 255, 255,
616		]),
617		i256::from_le_bytes([
618		1, 0, 0, 0, 0, 0, 0, 24, 183, 164, 194, 138, 251, 146, 220, 208, 127, 95, 201, 163, 253,
619		72, 175, 17, 240, 255, 255, 255, 255, 255, 255, 255,
620		]),
621		i256::from_le_bytes([
622		1, 0, 0, 0, 0, 0, 0, 240, 38, 111, 154, 107, 211, 189, 157, 40, 254, 186, 221, 101, 232,
623		217, 216, 176, 96, 255, 255, 255, 255, 255, 255, 255,
624		]),
625		i256::from_le_bytes([
626		1, 0, 0, 0, 0, 0, 0, 96, 133, 87, 8, 52, 66, 106, 41, 150, 237, 77, 169, 250, 19, 131, 120,
627		232, 198, 249, 255, 255, 255, 255, 255, 255,
628		]),
629		i256::from_le_bytes([
630		1, 0, 0, 0, 0, 0, 0, 192, 53, 107, 83, 8, 150, 38, 158, 221, 71, 11, 157, 202, 199, 30,
631		181, 20, 197, 193, 255, 255, 255, 255, 255, 255,
632		]),
633		i256::from_le_bytes([
634		1, 0, 0, 0, 0, 0, 0, 128, 25, 48, 66, 83, 220, 129, 45, 168, 206, 112, 34, 234, 205, 51,
635		19, 207, 178, 145, 253, 255, 255, 255, 255, 255,
636		]),
637		i256::from_le_bytes([
638		1, 0, 0, 0, 0, 0, 0, 0, 255, 224, 149, 64, 155, 18, 199, 145, 18, 104, 88, 37, 11, 6, 192,
639		22, 252, 176, 231, 255, 255, 255, 255, 255,
640		]),
641		i256::from_le_bytes([
642		1, 0, 0, 0, 0, 0, 0, 0, 246, 201, 218, 133, 16, 186, 198, 177, 185, 16, 116, 117, 111, 60,
643		128, 227, 216, 233, 12, 255, 255, 255, 255, 255,
644		]),
645		i256::from_le_bytes([
646		1, 0, 0, 0, 0, 0, 0, 0, 156, 227, 139, 58, 165, 68, 195, 241, 64, 167, 136, 150, 90, 92, 2,
647		227, 120, 34, 129, 246, 255, 255, 255, 255,
648		]),
649		i256::from_le_bytes([
650		1, 0, 0, 0, 0, 0, 0, 0, 24, 228, 118, 73, 116, 174, 160, 113, 137, 136, 86, 225, 137, 155,
651		23, 222, 184, 88, 11, 161, 255, 255, 255, 255,
652		]),
653		i256::from_le_bytes([
654		1, 0, 0, 0, 0, 0, 0, 0, 240, 232, 164, 222, 138, 208, 70, 112, 94, 85, 97, 205, 98, 19,
655		236, 172, 56, 119, 113, 74, 252, 255, 255, 255,
656		]),
657		i256::from_le_bytes([
658		1, 0, 0, 0, 0, 0, 0, 0, 96, 25, 113, 178, 108, 37, 196, 98, 176, 85, 205, 5, 220, 193, 56,
659		193, 54, 168, 110, 232, 218, 255, 255, 255,
660		]),
661		i256::from_le_bytes([
662		1, 0, 0, 0, 0, 0, 0, 0, 192, 253, 106, 248, 62, 118, 169, 219, 227, 88, 5, 58, 152, 146,
663		55, 140, 35, 146, 82, 20, 141, 254, 255, 255,
664		]),
665		i256::from_le_bytes([
666		1, 0, 0, 0, 0, 0, 0, 0, 128, 233, 45, 180, 117, 158, 158, 148, 230, 120, 53, 68, 242, 185,
667		43, 122, 99, 181, 57, 203, 130, 241, 255, 255,
668		]),
669		i256::from_le_bytes([
670		1, 0, 0, 0, 0, 0, 0, 0, 0, 31, 203, 9, 153, 48, 50, 206, 1, 185, 22, 170, 118, 67, 181,
671		197, 226, 21, 65, 240, 27, 111, 255, 255,
672		]),
673		i256::from_le_bytes([
674		1, 0, 0, 0, 0, 0, 0, 0, 0, 54, 239, 97, 250, 229, 245, 13, 18, 58, 227, 164, 162, 162, 20,
675		185, 219, 218, 138, 98, 23, 87, 250, 255,
676		]),
677		i256::from_le_bytes([
678		1, 0, 0, 0, 0, 0, 0, 0, 0, 28, 88, 211, 199, 251, 154, 139, 180, 68, 224, 112, 90, 90, 206,
679		58, 149, 140, 108, 217, 233, 102, 199, 255,
680		]),
681		i256::from_le_bytes([
682		1, 0, 0, 0, 0, 0, 0, 0, 0, 24, 113, 65, 206, 213, 13, 116, 13, 175, 194, 104, 136, 135, 15,
683		76, 212, 125, 61, 126, 34, 5, 202, 253,
684		]),
685		i256::from_le_bytes([
686		1, 0, 0, 0, 0, 0, 0, 0, 0, 240, 106, 142, 14, 90, 138, 136, 134, 214, 154, 23, 84, 75, 155,
687		248, 74, 234, 102, 238, 88, 51, 228, 233,
688		]),
689		];
690
691		/// `MAX_DECIMAL_FOR_EACH_PRECISION[p-1]` holds the maximum `i128` value that can
692		/// be stored in a [`Decimal128`] value of precision `p`
693		///
694		/// [`Decimal128`]: arrow_schema::DataType::Decimal128
695		#[deprecated(
696		since = "54.1.0",
697		note = "Use MAX_DECIMAL128_FOR_EACH_PRECISION (note indexes are different)"
698		)]
699		#[allow(dead_code)] // no longer used but is part of our public API
700		pub const MAX_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
701		9,
702		99,
703		999,
704		9999,
705		99999,
706		999999,
707		9999999,
708		99999999,
709		999999999,
710		9999999999,
711		99999999999,
712		999999999999,
713		9999999999999,
714		99999999999999,
715		999999999999999,
716		9999999999999999,
717		99999999999999999,
718		999999999999999999,
719		9999999999999999999,
720		99999999999999999999,
721		999999999999999999999,
722		9999999999999999999999,
723		99999999999999999999999,
724		999999999999999999999999,
725		9999999999999999999999999,
726		99999999999999999999999999,
727		999999999999999999999999999,
728		9999999999999999999999999999,
729		99999999999999999999999999999,
730		999999999999999999999999999999,
731		9999999999999999999999999999999,
732		99999999999999999999999999999999,
733		999999999999999999999999999999999,
734		9999999999999999999999999999999999,
735		99999999999999999999999999999999999,
736		999999999999999999999999999999999999,
737		9999999999999999999999999999999999999,
738		99999999999999999999999999999999999999,
739		];
740
741		/// `MIN_DECIMAL_FOR_EACH_PRECISION[p-1]` holds the minimum `i128` value that can
742		/// be stored in a [`Decimal128`] value of precision `p`
743		///
744		/// [`Decimal128`]: arrow_schema::DataType::Decimal128
745		#[allow(dead_code)] // no longer used but is part of our public API
746		#[deprecated(
747		since = "54.1.0",
748		note = "Use MIN_DECIMAL128_FOR_EACH_PRECISION (note indexes are different)"
749		)]
750		pub const MIN_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
751		-9,
752		-99,
753		-999,
754		-9999,
755		-99999,
756		-999999,
757		-9999999,
758		-99999999,
759		-999999999,
760		-9999999999,
761		-99999999999,
762		-999999999999,
763		-9999999999999,
764		-99999999999999,
765		-999999999999999,
766		-9999999999999999,
767		-99999999999999999,
768		-999999999999999999,
769		-9999999999999999999,
770		-99999999999999999999,
771		-999999999999999999999,
772		-9999999999999999999999,
773		-99999999999999999999999,
774		-999999999999999999999999,
775		-9999999999999999999999999,
776		-99999999999999999999999999,
777		-999999999999999999999999999,
778		-9999999999999999999999999999,
779		-99999999999999999999999999999,
780		-999999999999999999999999999999,
781		-9999999999999999999999999999999,
782		-99999999999999999999999999999999,
783		-999999999999999999999999999999999,
784		-9999999999999999999999999999999999,
785		-99999999999999999999999999999999999,
786		-999999999999999999999999999999999999,
787		-9999999999999999999999999999999999999,
788		-99999999999999999999999999999999999999,
789		];
790
791		/// `MAX_DECIMAL128_FOR_EACH_PRECISION[p]` holds the maximum `i128` value that can
792		/// be stored in [`Decimal128`] value of precision `p`.
793		///
794		/// # Notes
795		///
796		/// The first element is unused and is inserted so that we can look up using
797		/// precision as the index without the need to subtract 1 first.
798		///
799		/// # Example
800		/// ```
801		/// # use arrow_data::decimal::MAX_DECIMAL128_FOR_EACH_PRECISION;
802		/// assert_eq!(MAX_DECIMAL128_FOR_EACH_PRECISION[3], 999);
803		/// ```
804		///
805		/// [`Decimal128`]: arrow_schema::DataType::Decimal128
806		pub const MAX_DECIMAL128_FOR_EACH_PRECISION: [i128; 39] = [
807		0, // unused first element
808		9,
809		99,
810		999,
811		9999,
812		99999,
813		999999,
814		9999999,
815		99999999,
816		999999999,
817		9999999999,
818		99999999999,
819		999999999999,
820		9999999999999,
821		99999999999999,
822		999999999999999,
823		9999999999999999,
824		99999999999999999,
825		999999999999999999,
826		9999999999999999999,
827		99999999999999999999,
828		999999999999999999999,
829		9999999999999999999999,
830		99999999999999999999999,
831		999999999999999999999999,
832		9999999999999999999999999,
833		99999999999999999999999999,
834		999999999999999999999999999,
835		9999999999999999999999999999,
836		99999999999999999999999999999,
837		999999999999999999999999999999,
838		9999999999999999999999999999999,
839		99999999999999999999999999999999,
840		999999999999999999999999999999999,
841		9999999999999999999999999999999999,
842		99999999999999999999999999999999999,
843		999999999999999999999999999999999999,
844		9999999999999999999999999999999999999,
845		99999999999999999999999999999999999999,
846		];
847
848		/// `MIN_DECIMAL_FOR_EACH_PRECISION[p]` holds the minimum `i128` value that can
849		/// be stored in a [`Decimal128`] value of precision `p`.
850		///
851		/// # Notes
852		///
853		/// The first element is unused and is inserted so that we can look up using
854		/// precision as the index without the need to subtract 1 first.
855		///
856		/// # Example
857		/// ```
858		/// # use arrow_data::decimal::MIN_DECIMAL128_FOR_EACH_PRECISION;
859		/// assert_eq!(MIN_DECIMAL128_FOR_EACH_PRECISION[3], -999);
860		/// ```
861		///
862		/// [`Decimal128`]: arrow_schema::DataType::Decimal128
863		pub const MIN_DECIMAL128_FOR_EACH_PRECISION: [i128; 39] = [
864		0, // unused first element
865		-9,
866		-99,
867		-999,
868		-9999,
869		-99999,
870		-999999,
871		-9999999,
872		-99999999,
873		-999999999,
874		-9999999999,
875		-99999999999,
876		-999999999999,
877		-9999999999999,
878		-99999999999999,
879		-999999999999999,
880		-9999999999999999,
881		-99999999999999999,
882		-999999999999999999,
883		-9999999999999999999,
884		-99999999999999999999,
885		-999999999999999999999,
886		-9999999999999999999999,
887		-99999999999999999999999,
888		-999999999999999999999999,
889		-9999999999999999999999999,
890		-99999999999999999999999999,
891		-999999999999999999999999999,
892		-9999999999999999999999999999,
893		-99999999999999999999999999999,
894		-999999999999999999999999999999,
895		-9999999999999999999999999999999,
896		-99999999999999999999999999999999,
897		-999999999999999999999999999999999,
898		-9999999999999999999999999999999999,
899		-99999999999999999999999999999999999,
900		-999999999999999999999999999999999999,
901		-9999999999999999999999999999999999999,
902		-99999999999999999999999999999999999999,
903		];
904
905		/// `MAX_DECIMAL64_FOR_EACH_PRECISION[p]` holds the maximum `i64` value that can
906		/// be stored in [`Decimal64`] value of precision `p`.
907		///
908		/// # Notes
909		///
910		/// The first element is unused and is inserted so that we can look up using
911		/// precision as the index without the need to subtract 1 first.
912		///
913		/// # Example
914		/// ```
915		/// # use arrow_data::decimal::MAX_DECIMAL64_FOR_EACH_PRECISION;
916		/// assert_eq!(MAX_DECIMAL64_FOR_EACH_PRECISION[3], 999);
917		/// ```
918		///
919		/// [`Decimal64`]: arrow_schema::DataType::Decimal64
920		pub const MAX_DECIMAL64_FOR_EACH_PRECISION: [i64; 19] = [
921		0, // unused first element
922		9,
923		99,
924		999,
925		9999,
926		99999,
927		999999,
928		9999999,
929		99999999,
930		999999999,
931		9999999999,
932		99999999999,
933		999999999999,
934		9999999999999,
935		99999999999999,
936		999999999999999,
937		9999999999999999,
938		99999999999999999,
939		999999999999999999,
940		];
941
942		/// `MIN_DECIMAL64_FOR_EACH_PRECISION[p]` holds the minimum `i64` value that can
943		/// be stored in a [`Decimal64`] value of precision `p`.
944		///
945		/// # Notes
946		///
947		/// The first element is unused and is inserted so that we can look up using
948		/// precision as the index without the need to subtract 1 first.
949		///
950		/// # Example
951		/// ```
952		/// # use arrow_data::decimal::MIN_DECIMAL64_FOR_EACH_PRECISION;
953		/// assert_eq!(MIN_DECIMAL64_FOR_EACH_PRECISION[3], -999);
954		/// ```
955		///
956		/// [`Decimal64`]: arrow_schema::DataType::Decimal64
957		pub const MIN_DECIMAL64_FOR_EACH_PRECISION: [i64; 19] = [
958		0, // unused first element
959		-9,
960		-99,
961		-999,
962		-9999,
963		-99999,
964		-999999,
965		-9999999,
966		-99999999,
967		-999999999,
968		-9999999999,
969		-99999999999,
970		-999999999999,
971		-9999999999999,
972		-99999999999999,
973		-999999999999999,
974		-9999999999999999,
975		-99999999999999999,
976		-999999999999999999,
977		];
978
979		/// `MAX_DECIMAL32_FOR_EACH_PRECISION[p]` holds the maximum `i32` value that can
980		/// be stored in [`Decimal32`] value of precision `p`.
981		///
982		/// # Notes
983		///
984		/// The first element is unused and is inserted so that we can look up using
985		/// precision as the index without the need to subtract 1 first.
986		///
987		/// # Example
988		/// ```
989		/// # use arrow_data::decimal::MAX_DECIMAL32_FOR_EACH_PRECISION;
990		/// assert_eq!(MAX_DECIMAL32_FOR_EACH_PRECISION[3], 999);
991		/// ```
992		///
993		/// [`Decimal32`]: arrow_schema::DataType::Decimal32
994		pub const MAX_DECIMAL32_FOR_EACH_PRECISION: [i32; 10] = [
995		0, // unused first element
996		9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999,
997		];
998
999		/// `MIN_DECIMAL32_FOR_EACH_PRECISION[p]` holds the minimum `ialue that can
1000		/// be stored in a [`Decimal32`] value of precision `p`.
1001		///
1002		/// # Notes
1003		///
1004		/// The first element is unused and is inserted so that we can look up using
1005		/// precision as the index without the need to subtract 1 first.
1006		///
1007		/// # Example
1008		/// ```
1009		/// # use arrow_data::decimal::MIN_DECIMAL32_FOR_EACH_PRECISION;
1010		/// assert_eq!(MIN_DECIMAL32_FOR_EACH_PRECISION[3], -999);
1011		/// ```
1012		///
1013		/// [`Decimal32`]: arrow_schema::DataType::Decimal32
1014		pub const MIN_DECIMAL32_FOR_EACH_PRECISION: [i32; 10] = [
1015		0, // unused first element
1016		-9, -99, -999, -9999, -99999, -999999, -9999999, -99999999, -999999999,
1017		];
1018
1019		/// Validates that the specified `i32` value can be properly
1020		/// interpreted as a [`Decimal32`] number with precision `precision`
1021		///
1022		/// [`Decimal32`]: arrow_schema::DataType::Decimal32
1023		#[inline]
1024	0	pub fn validate_decimal32_precision(value: i32, precision: u8) -> Result<(), ArrowError> {
1025	0	if precision > DECIMAL32_MAX_PRECISION {
1026	0	return Err(ArrowError::InvalidArgumentError(format!(
1027	0	"Max precision of a Decimal32 is {DECIMAL32_MAX_PRECISION}, but got {precision}",
1028	0	)));
1029	0	}
1030	0	if value > MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
1031	0	Err(ArrowError::InvalidArgumentError(format!(
1032	0	"{value} is too large to store in a Decimal32 of precision {precision}. Max is {}",
1033	0	MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
1034	0	)))
1035	0	} else if value < MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
1036	0	Err(ArrowError::InvalidArgumentError(format!(
1037	0	"{value} is too small to store in a Decimal32 of precision {precision}. Min is {}",
1038	0	MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
1039	0	)))
1040		} else {
1041	0	Ok(())
1042		}
1043	0	}
1044
1045		/// Returns true if the specified `i32` value can be properly
1046		/// interpreted as a [`Decimal32`] number with precision `precision`
1047		///
1048		/// [`Decimal32`]: arrow_schema::DataType::Decimal32
1049		#[inline]
1050	0	pub fn is_validate_decimal32_precision(value: i32, precision: u8) -> bool {
1051	0	precision <= DECIMAL32_MAX_PRECISION
1052	0	&& value >= MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
1053	0	&& value <= MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
1054	0	}
1055
1056		/// Validates that the specified `i64` value can be properly
1057		/// interpreted as a [`Decimal64`] number with precision `precision`
1058		///
1059		/// [`Decimal64`]: arrow_schema::DataType::Decimal64
1060		#[inline]
1061	0	pub fn validate_decimal64_precision(value: i64, precision: u8) -> Result<(), ArrowError> {
1062	0	if precision > DECIMAL64_MAX_PRECISION {
1063	0	return Err(ArrowError::InvalidArgumentError(format!(
1064	0	"Max precision of a Decimal64 is {DECIMAL64_MAX_PRECISION}, but got {precision}",
1065	0	)));
1066	0	}
1067	0	if value > MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
1068	0	Err(ArrowError::InvalidArgumentError(format!(
1069	0	"{value} is too large to store in a Decimal64 of precision {precision}. Max is {}",
1070	0	MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1071	0	)))
1072	0	} else if value < MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
1073	0	Err(ArrowError::InvalidArgumentError(format!(
1074	0	"{value} is too small to store in a Decimal64 of precision {precision}. Min is {}",
1075	0	MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1076	0	)))
1077		} else {
1078	0	Ok(())
1079		}
1080	0	}
1081
1082		/// Returns true if the specified `i64` value can be properly
1083		/// interpreted as a [`Decimal64`] number with precision `precision`
1084		///
1085		/// [`Decimal64`]: arrow_schema::DataType::Decimal64
1086		#[inline]
1087	0	pub fn is_validate_decimal64_precision(value: i64, precision: u8) -> bool {
1088	0	precision <= DECIMAL64_MAX_PRECISION
1089	0	&& value >= MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1090	0	&& value <= MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1091	0	}
1092
1093		/// Validates that the specified `i128` value can be properly
1094		/// interpreted as a [`Decimal128`] number with precision `precision`
1095		///
1096		/// [`Decimal128`]: arrow_schema::DataType::Decimal128
1097		#[inline]
1098	0	pub fn validate_decimal_precision(value: i128, precision: u8) -> Result<(), ArrowError> {
1099	0	if precision > DECIMAL128_MAX_PRECISION {
1100	0	return Err(ArrowError::InvalidArgumentError(format!(
1101	0	"Max precision of a Decimal128 is {DECIMAL128_MAX_PRECISION}, but got {precision}",
1102	0	)));
1103	0	}
1104	0	if value > MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
1105	0	Err(ArrowError::InvalidArgumentError(format!(
1106	0	"{value} is too large to store in a Decimal128 of precision {precision}. Max is {}",
1107	0	MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1108	0	)))
1109	0	} else if value < MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
1110	0	Err(ArrowError::InvalidArgumentError(format!(
1111	0	"{value} is too small to store in a Decimal128 of precision {precision}. Min is {}",
1112	0	MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1113	0	)))
1114		} else {
1115	0	Ok(())
1116		}
1117	0	}
1118
1119		/// Returns true if the specified `i128` value can be properly
1120		/// interpreted as a [`Decimal128`] number with precision `precision`
1121		///
1122		/// [`Decimal128`]: arrow_schema::DataType::Decimal128
1123		#[inline]
1124	0	pub fn is_validate_decimal_precision(value: i128, precision: u8) -> bool {
1125	0	precision <= DECIMAL128_MAX_PRECISION
1126	0	&& value >= MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1127	0	&& value <= MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1128	0	}
1129
1130		/// Validates that the specified `i256` of value can be properly
1131		/// interpreted as a [`Decimal256`] number with precision `precision`
1132		///
1133		/// [`Decimal256`]: arrow_schema::DataType::Decimal256
1134		#[inline]
1135	0	pub fn validate_decimal256_precision(value: i256, precision: u8) -> Result<(), ArrowError> {
1136	0	if precision > DECIMAL256_MAX_PRECISION {
1137	0	return Err(ArrowError::InvalidArgumentError(format!(
1138	0	"Max precision of a Decimal256 is {DECIMAL256_MAX_PRECISION}, but got {precision}",
1139	0	)));
1140	0	}
1141	0	if value > MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
1142	0	Err(ArrowError::InvalidArgumentError(format!(
1143	0	"{value:?} is too large to store in a Decimal256 of precision {precision}. Max is {:?}",
1144	0	MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1145	0	)))
1146	0	} else if value < MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
1147	0	Err(ArrowError::InvalidArgumentError(format!(
1148	0	"{value:?} is too small to store in a Decimal256 of precision {precision}. Min is {:?}",
1149	0	MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1150	0	)))
1151		} else {
1152	0	Ok(())
1153		}
1154	0	}
1155
1156		/// Return true if the specified `i256` value can be properly
1157		/// interpreted as a [`Decimal256`] number with precision `precision`
1158		///
1159		/// [`Decimal256`]: arrow_schema::DataType::Decimal256
1160		#[inline]
1161	0	pub fn is_validate_decimal256_precision(value: i256, precision: u8) -> bool {
1162	0	precision <= DECIMAL256_MAX_PRECISION
1163	0	&& value >= MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1164	0	&& value <= MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1165	0	}

Coverage Report

Created: 2025-08-26 07:03