arrow_data/
decimal.rs

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
27use arrow_buffer::i256;
28use arrow_schema::ArrowError;
29
30pub use arrow_schema::{
31    DECIMAL_DEFAULT_SCALE, DECIMAL32_DEFAULT_SCALE, DECIMAL32_MAX_PRECISION, DECIMAL32_MAX_SCALE,
32    DECIMAL64_DEFAULT_SCALE, DECIMAL64_MAX_PRECISION, DECIMAL64_MAX_SCALE,
33    DECIMAL128_MAX_PRECISION, DECIMAL128_MAX_SCALE, DECIMAL256_MAX_PRECISION, DECIMAL256_MAX_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
56pub 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
383pub 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_DECIMAL128_FOR_EACH_PRECISION[p]` holds the maximum `i128` value that can
692/// be stored in [`Decimal128`] value of precision `p`.
693///
694/// # Notes
695///
696/// The first element is unused and is inserted so that we can look up using
697/// precision as the index without the need to subtract 1 first.
698///
699/// # Example
700/// ```
701/// # use arrow_data::decimal::MAX_DECIMAL128_FOR_EACH_PRECISION;
702/// assert_eq!(MAX_DECIMAL128_FOR_EACH_PRECISION[3], 999);
703/// ```
704///
705/// [`Decimal128`]: arrow_schema::DataType::Decimal128
706pub const MAX_DECIMAL128_FOR_EACH_PRECISION: [i128; 39] = [
707    0, // unused first element
708    9,
709    99,
710    999,
711    9999,
712    99999,
713    999999,
714    9999999,
715    99999999,
716    999999999,
717    9999999999,
718    99999999999,
719    999999999999,
720    9999999999999,
721    99999999999999,
722    999999999999999,
723    9999999999999999,
724    99999999999999999,
725    999999999999999999,
726    9999999999999999999,
727    99999999999999999999,
728    999999999999999999999,
729    9999999999999999999999,
730    99999999999999999999999,
731    999999999999999999999999,
732    9999999999999999999999999,
733    99999999999999999999999999,
734    999999999999999999999999999,
735    9999999999999999999999999999,
736    99999999999999999999999999999,
737    999999999999999999999999999999,
738    9999999999999999999999999999999,
739    99999999999999999999999999999999,
740    999999999999999999999999999999999,
741    9999999999999999999999999999999999,
742    99999999999999999999999999999999999,
743    999999999999999999999999999999999999,
744    9999999999999999999999999999999999999,
745    99999999999999999999999999999999999999,
746];
747
748/// `MIN_DECIMAL_FOR_EACH_PRECISION[p]` holds the minimum `i128` value that can
749/// be stored in a [`Decimal128`] value of precision `p`.
750///
751/// # Notes
752///
753/// The first element is unused and is inserted so that we can look up using
754/// precision as the index without the need to subtract 1 first.
755///
756/// # Example
757/// ```
758/// # use arrow_data::decimal::MIN_DECIMAL128_FOR_EACH_PRECISION;
759/// assert_eq!(MIN_DECIMAL128_FOR_EACH_PRECISION[3], -999);
760/// ```
761///
762/// [`Decimal128`]: arrow_schema::DataType::Decimal128
763pub const MIN_DECIMAL128_FOR_EACH_PRECISION: [i128; 39] = [
764    0, // unused first element
765    -9,
766    -99,
767    -999,
768    -9999,
769    -99999,
770    -999999,
771    -9999999,
772    -99999999,
773    -999999999,
774    -9999999999,
775    -99999999999,
776    -999999999999,
777    -9999999999999,
778    -99999999999999,
779    -999999999999999,
780    -9999999999999999,
781    -99999999999999999,
782    -999999999999999999,
783    -9999999999999999999,
784    -99999999999999999999,
785    -999999999999999999999,
786    -9999999999999999999999,
787    -99999999999999999999999,
788    -999999999999999999999999,
789    -9999999999999999999999999,
790    -99999999999999999999999999,
791    -999999999999999999999999999,
792    -9999999999999999999999999999,
793    -99999999999999999999999999999,
794    -999999999999999999999999999999,
795    -9999999999999999999999999999999,
796    -99999999999999999999999999999999,
797    -999999999999999999999999999999999,
798    -9999999999999999999999999999999999,
799    -99999999999999999999999999999999999,
800    -999999999999999999999999999999999999,
801    -9999999999999999999999999999999999999,
802    -99999999999999999999999999999999999999,
803];
804
805/// `MAX_DECIMAL64_FOR_EACH_PRECISION[p]` holds the maximum `i64` value that can
806/// be stored in [`Decimal64`] value of precision `p`.
807///
808/// # Notes
809///
810/// The first element is unused and is inserted so that we can look up using
811/// precision as the index without the need to subtract 1 first.
812///
813/// # Example
814/// ```
815/// # use arrow_data::decimal::MAX_DECIMAL64_FOR_EACH_PRECISION;
816/// assert_eq!(MAX_DECIMAL64_FOR_EACH_PRECISION[3], 999);
817/// ```
818///
819/// [`Decimal64`]: arrow_schema::DataType::Decimal64
820pub const MAX_DECIMAL64_FOR_EACH_PRECISION: [i64; 19] = [
821    0, // unused first element
822    9,
823    99,
824    999,
825    9999,
826    99999,
827    999999,
828    9999999,
829    99999999,
830    999999999,
831    9999999999,
832    99999999999,
833    999999999999,
834    9999999999999,
835    99999999999999,
836    999999999999999,
837    9999999999999999,
838    99999999999999999,
839    999999999999999999,
840];
841
842/// `MIN_DECIMAL64_FOR_EACH_PRECISION[p]` holds the minimum `i64` value that can
843/// be stored in a [`Decimal64`] value of precision `p`.
844///
845/// # Notes
846///
847/// The first element is unused and is inserted so that we can look up using
848/// precision as the index without the need to subtract 1 first.
849///
850/// # Example
851/// ```
852/// # use arrow_data::decimal::MIN_DECIMAL64_FOR_EACH_PRECISION;
853/// assert_eq!(MIN_DECIMAL64_FOR_EACH_PRECISION[3], -999);
854/// ```
855///
856/// [`Decimal64`]: arrow_schema::DataType::Decimal64
857pub const MIN_DECIMAL64_FOR_EACH_PRECISION: [i64; 19] = [
858    0, // unused first element
859    -9,
860    -99,
861    -999,
862    -9999,
863    -99999,
864    -999999,
865    -9999999,
866    -99999999,
867    -999999999,
868    -9999999999,
869    -99999999999,
870    -999999999999,
871    -9999999999999,
872    -99999999999999,
873    -999999999999999,
874    -9999999999999999,
875    -99999999999999999,
876    -999999999999999999,
877];
878
879/// `MAX_DECIMAL32_FOR_EACH_PRECISION[p]` holds the maximum `i32` value that can
880/// be stored in [`Decimal32`] value of precision `p`.
881///
882/// # Notes
883///
884/// The first element is unused and is inserted so that we can look up using
885/// precision as the index without the need to subtract 1 first.
886///
887/// # Example
888/// ```
889/// # use arrow_data::decimal::MAX_DECIMAL32_FOR_EACH_PRECISION;
890/// assert_eq!(MAX_DECIMAL32_FOR_EACH_PRECISION[3], 999);
891/// ```
892///
893/// [`Decimal32`]: arrow_schema::DataType::Decimal32
894pub const MAX_DECIMAL32_FOR_EACH_PRECISION: [i32; 10] = [
895    0, // unused first element
896    9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999,
897];
898
899/// `MIN_DECIMAL32_FOR_EACH_PRECISION[p]` holds the minimum value that can
900/// be stored in a [`Decimal32`] value of precision `p`.
901///
902/// # Notes
903///
904/// The first element is unused and is inserted so that we can look up using
905/// precision as the index without the need to subtract 1 first.
906///
907/// # Example
908/// ```
909/// # use arrow_data::decimal::MIN_DECIMAL32_FOR_EACH_PRECISION;
910/// assert_eq!(MIN_DECIMAL32_FOR_EACH_PRECISION[3], -999);
911/// ```
912///
913/// [`Decimal32`]: arrow_schema::DataType::Decimal32
914pub const MIN_DECIMAL32_FOR_EACH_PRECISION: [i32; 10] = [
915    0, // unused first element
916    -9, -99, -999, -9999, -99999, -999999, -9999999, -99999999, -999999999,
917];
918
919/// Validates that the specified `i32` value can be properly
920/// interpreted as a [`Decimal32`] number with precision `precision`
921///
922/// [`Decimal32`]: arrow_schema::DataType::Decimal32
923#[inline]
924pub fn validate_decimal32_precision(
925    value: i32,
926    precision: u8,
927    scale: i8,
928) -> Result<(), ArrowError> {
929    if precision > DECIMAL32_MAX_PRECISION {
930        return Err(ArrowError::InvalidArgumentError(format!(
931            "Max precision of a Decimal32 is {DECIMAL32_MAX_PRECISION}, but got {precision}",
932        )));
933    }
934    if value > MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
935        let unscaled_value = format_decimal_str_internal(&value.to_string(), scale);
936        let unscale_max_value = format_decimal_str(
937            &MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize].to_string(),
938            precision.into(),
939            scale,
940        );
941        Err(ArrowError::InvalidArgumentError(format!(
942            "{unscaled_value} is too large to store in a Decimal32 of precision {precision}. Max is {unscale_max_value}"
943        )))
944    } else if value < MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
945        let unscaled_value = format_decimal_str_internal(&value.to_string(), scale);
946        let unscale_min_value = format_decimal_str(
947            &MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize].to_string(),
948            precision.into(),
949            scale,
950        );
951        Err(ArrowError::InvalidArgumentError(format!(
952            "{unscaled_value} is too small to store in a Decimal32 of precision {precision}. Min is {unscale_min_value}"
953        )))
954    } else {
955        Ok(())
956    }
957}
958
959/// Returns true if the specified `i32` value can be properly
960/// interpreted as a [`Decimal32`] number with precision `precision`
961///
962/// [`Decimal32`]: arrow_schema::DataType::Decimal32
963#[inline]
964pub fn is_validate_decimal32_precision(value: i32, precision: u8) -> bool {
965    precision <= DECIMAL32_MAX_PRECISION
966        && value >= MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
967        && value <= MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
968}
969
970/// Validates that the specified `i64` value can be properly
971/// interpreted as a [`Decimal64`] number with precision `precision`
972///
973/// [`Decimal64`]: arrow_schema::DataType::Decimal64
974#[inline]
975pub fn validate_decimal64_precision(
976    value: i64,
977    precision: u8,
978    scale: i8,
979) -> Result<(), ArrowError> {
980    if precision > DECIMAL64_MAX_PRECISION {
981        return Err(ArrowError::InvalidArgumentError(format!(
982            "Max precision of a Decimal64 is {DECIMAL64_MAX_PRECISION}, but got {precision}",
983        )));
984    }
985    if value > MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
986        let unscaled_value = format_decimal_str_internal(&value.to_string(), scale);
987        let unscaled_max_value = format_decimal_str(
988            &MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize].to_string(),
989            precision.into(),
990            scale,
991        );
992        Err(ArrowError::InvalidArgumentError(format!(
993            "{unscaled_value} is too large to store in a Decimal64 of precision {precision}. Max is {unscaled_max_value}"
994        )))
995    } else if value < MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
996        let unscaled_value = format_decimal_str_internal(&value.to_string(), scale);
997        let unscaled_min_value = format_decimal_str(
998            &MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize].to_string(),
999            precision.into(),
1000            scale,
1001        );
1002        Err(ArrowError::InvalidArgumentError(format!(
1003            "{unscaled_value} is too small to store in a Decimal64 of precision {precision}. Min is {unscaled_min_value}"
1004        )))
1005    } else {
1006        Ok(())
1007    }
1008}
1009
1010/// Returns true if the specified `i64` value can be properly
1011/// interpreted as a [`Decimal64`] number with precision `precision`
1012///
1013/// [`Decimal64`]: arrow_schema::DataType::Decimal64
1014#[inline]
1015pub fn is_validate_decimal64_precision(value: i64, precision: u8) -> bool {
1016    precision <= DECIMAL64_MAX_PRECISION
1017        && value >= MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1018        && value <= MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1019}
1020
1021/// Validates that the specified `i128` value can be properly
1022/// interpreted as a [`Decimal128`] number with precision `precision`
1023///
1024/// [`Decimal128`]: arrow_schema::DataType::Decimal128
1025#[inline]
1026pub fn validate_decimal_precision(value: i128, precision: u8, scale: i8) -> Result<(), ArrowError> {
1027    if precision > DECIMAL128_MAX_PRECISION {
1028        return Err(ArrowError::InvalidArgumentError(format!(
1029            "Max precision of a Decimal128 is {DECIMAL128_MAX_PRECISION}, but got {precision}",
1030        )));
1031    }
1032    if value > MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
1033        let unscaled_value = format_decimal_str_internal(&value.to_string(), scale);
1034        let unscaled_max_value = format_decimal_str(
1035            &MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize].to_string(),
1036            precision.into(),
1037            scale,
1038        );
1039        Err(ArrowError::InvalidArgumentError(format!(
1040            "{unscaled_value} is too large to store in a Decimal128 of precision {precision}. Max is {unscaled_max_value}"
1041        )))
1042    } else if value < MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
1043        let unscaled_value = format_decimal_str_internal(&value.to_string(), scale);
1044        let unscaled_min_value = format_decimal_str(
1045            &MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize].to_string(),
1046            precision.into(),
1047            scale,
1048        );
1049        Err(ArrowError::InvalidArgumentError(format!(
1050            "{unscaled_value} is too small to store in a Decimal128 of precision {precision}. Min is {unscaled_min_value}"
1051        )))
1052    } else {
1053        Ok(())
1054    }
1055}
1056
1057/// Returns true if the specified `i128` value can be properly
1058/// interpreted as a [`Decimal128`] number with precision `precision`
1059///
1060/// [`Decimal128`]: arrow_schema::DataType::Decimal128
1061#[inline]
1062pub fn is_validate_decimal_precision(value: i128, precision: u8) -> bool {
1063    precision <= DECIMAL128_MAX_PRECISION
1064        && value >= MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1065        && value <= MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1066}
1067
1068/// Validates that the specified `i256` of value can be properly
1069/// interpreted as a [`Decimal256`] number with precision `precision`
1070///
1071/// [`Decimal256`]: arrow_schema::DataType::Decimal256
1072#[inline]
1073pub fn validate_decimal256_precision(
1074    value: i256,
1075    precision: u8,
1076    scale: i8,
1077) -> Result<(), ArrowError> {
1078    if precision > DECIMAL256_MAX_PRECISION {
1079        return Err(ArrowError::InvalidArgumentError(format!(
1080            "Max precision of a Decimal256 is {DECIMAL256_MAX_PRECISION}, but got {precision}",
1081        )));
1082    }
1083
1084    if value > MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
1085        let unscaled_value = format_decimal_str_internal(&value.to_string(), scale);
1086        let unscaled_max_value = format_decimal_str(
1087            &MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize].to_string(),
1088            precision.into(),
1089            scale,
1090        );
1091        Err(ArrowError::InvalidArgumentError(format!(
1092            "{unscaled_value} is too large to store in a Decimal256 of precision {precision}. Max is {unscaled_max_value}"
1093        )))
1094    } else if value < MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
1095        let unscaled_value = format_decimal_str_internal(&value.to_string(), scale);
1096        let unscaled_min_value = format_decimal_str(
1097            &MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize].to_string(),
1098            precision.into(),
1099            scale,
1100        );
1101        Err(ArrowError::InvalidArgumentError(format!(
1102            "{unscaled_value} is too small to store in a Decimal256 of precision {precision}. Min is {unscaled_min_value}"
1103        )))
1104    } else {
1105        Ok(())
1106    }
1107}
1108
1109/// Return true if the specified `i256` value can be properly
1110/// interpreted as a [`Decimal256`] number with precision `precision`
1111///
1112/// [`Decimal256`]: arrow_schema::DataType::Decimal256
1113#[inline]
1114pub fn is_validate_decimal256_precision(value: i256, precision: u8) -> bool {
1115    precision <= DECIMAL256_MAX_PRECISION
1116        && value >= MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1117        && value <= MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1118}
1119
1120#[inline]
1121/// Formats a decimal string given the scale.
1122///
1123/// The value is always formatted in full: `_precision` is unused and retained
1124/// only for API compatibility.
1125pub fn format_decimal_str(value_str: &str, _precision: usize, scale: i8) -> String {
1126    format_decimal_str_internal(value_str, scale)
1127}
1128
1129// Format a decimal string given the scale.
1130fn format_decimal_str_internal(value_str: &str, scale: i8) -> String {
1131    let (sign, rest) = match value_str.strip_prefix('-') {
1132        Some(stripped) => ("-", stripped),
1133        None => ("", value_str),
1134    };
1135
1136    if scale == 0 {
1137        value_str.to_string()
1138    } else if scale < 0 {
1139        if rest == "0" {
1140            // Zero must not be zero-padded ("000" is not a valid number)
1141            value_str.to_string()
1142        } else {
1143            let padding = value_str.len() + scale.unsigned_abs() as usize;
1144            format!("{value_str:0<padding$}")
1145        }
1146    } else if rest.len() > scale as usize {
1147        // Decimal separator is in the middle of the string
1148        let (whole, decimal) = value_str.split_at(value_str.len() - scale as usize);
1149        format!("{whole}.{decimal}")
1150    } else {
1151        // String has to be padded
1152        format!("{}0.{:0>width$}", sign, rest, width = scale as usize)
1153    }
1154}
1155
1156#[cfg(test)]
1157mod tests {
1158    use super::*;
1159
1160    #[test]
1161    fn test_format_decimal_str() {
1162        assert_eq!(format_decimal_str("12345", 7, 0), "12345");
1163        assert_eq!(format_decimal_str("12345", 7, 2), "123.45");
1164        assert_eq!(format_decimal_str("-12345", 7, 2), "-123.45");
1165        assert_eq!(format_decimal_str("45", 7, 3), "0.045");
1166        assert_eq!(format_decimal_str("-45", 7, 3), "-0.045");
1167        assert_eq!(format_decimal_str("0", 7, 2), "0.00");
1168        assert_eq!(format_decimal_str("12345", 7, 5), "0.12345");
1169
1170        // negative scales multiply the value by 10^|scale|
1171        assert_eq!(format_decimal_str("12", 7, -2), "1200");
1172        assert_eq!(format_decimal_str("-12", 7, -2), "-1200");
1173        // a zero value is not padded
1174        // https://github.com/apache/arrow-rs/issues/10865
1175        assert_eq!(format_decimal_str("0", 7, -2), "0");
1176
1177        // values exceeding the declared precision are still formatted in full
1178        // https://github.com/apache/arrow-rs/issues/10866
1179        assert_eq!(format_decimal_str("12345", 3, 1), "1234.5");
1180        assert_eq!(format_decimal_str("12345", 3, 3), "12.345");
1181        assert_eq!(format_decimal_str("-12345", 3, 3), "-12.345");
1182        assert_eq!(format_decimal_str("12345", 2, 4), "1.2345");
1183    }
1184}
arrow_data/decimal.rs

arrow_data/
decimal.rs
