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 `ialue 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 =
936            format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
937        let unscale_max_value = format_decimal_str(
938            &MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize].to_string(),
939            precision.into(),
940            scale,
941        );
942        Err(ArrowError::InvalidArgumentError(format!(
943            "{unscaled_value} is too large to store in a Decimal32 of precision {precision}. Max is {}",
944            unscale_max_value
945        )))
946    } else if value < MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
947        let unscaled_value =
948            format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
949        let unscale_min_value = format_decimal_str(
950            &MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize].to_string(),
951            precision.into(),
952            scale,
953        );
954        Err(ArrowError::InvalidArgumentError(format!(
955            "{unscaled_value} is too small to store in a Decimal32 of precision {precision}. Min is {}",
956            unscale_min_value
957        )))
958    } else {
959        Ok(())
960    }
961}
962
963/// Returns true if the specified `i32` value can be properly
964/// interpreted as a [`Decimal32`] number with precision `precision`
965///
966/// [`Decimal32`]: arrow_schema::DataType::Decimal32
967#[inline]
968pub fn is_validate_decimal32_precision(value: i32, precision: u8) -> bool {
969    precision <= DECIMAL32_MAX_PRECISION
970        && value >= MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
971        && value <= MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
972}
973
974/// Validates that the specified `i64` value can be properly
975/// interpreted as a [`Decimal64`] number with precision `precision`
976///
977/// [`Decimal64`]: arrow_schema::DataType::Decimal64
978#[inline]
979pub fn validate_decimal64_precision(
980    value: i64,
981    precision: u8,
982    scale: i8,
983) -> Result<(), ArrowError> {
984    if precision > DECIMAL64_MAX_PRECISION {
985        return Err(ArrowError::InvalidArgumentError(format!(
986            "Max precision of a Decimal64 is {DECIMAL64_MAX_PRECISION}, but got {precision}",
987        )));
988    }
989    if value > MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
990        let unscaled_value =
991            format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
992        let unscaled_max_value = format_decimal_str(
993            &MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize].to_string(),
994            precision.into(),
995            scale,
996        );
997        Err(ArrowError::InvalidArgumentError(format!(
998            "{unscaled_value} is too large to store in a Decimal64 of precision {precision}. Max is {}",
999            unscaled_max_value
1000        )))
1001    } else if value < MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
1002        let unscaled_value =
1003            format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
1004        let unscaled_min_value = format_decimal_str(
1005            &MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize].to_string(),
1006            precision.into(),
1007            scale,
1008        );
1009        Err(ArrowError::InvalidArgumentError(format!(
1010            "{unscaled_value} is too small to store in a Decimal64 of precision {precision}. Min is {}",
1011            unscaled_min_value
1012        )))
1013    } else {
1014        Ok(())
1015    }
1016}
1017
1018/// Returns true if the specified `i64` value can be properly
1019/// interpreted as a [`Decimal64`] number with precision `precision`
1020///
1021/// [`Decimal64`]: arrow_schema::DataType::Decimal64
1022#[inline]
1023pub fn is_validate_decimal64_precision(value: i64, precision: u8) -> bool {
1024    precision <= DECIMAL64_MAX_PRECISION
1025        && value >= MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1026        && value <= MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1027}
1028
1029/// Validates that the specified `i128` value can be properly
1030/// interpreted as a [`Decimal128`] number with precision `precision`
1031///
1032/// [`Decimal128`]: arrow_schema::DataType::Decimal128
1033#[inline]
1034pub fn validate_decimal_precision(value: i128, precision: u8, scale: i8) -> Result<(), ArrowError> {
1035    if precision > DECIMAL128_MAX_PRECISION {
1036        return Err(ArrowError::InvalidArgumentError(format!(
1037            "Max precision of a Decimal128 is {DECIMAL128_MAX_PRECISION}, but got {precision}",
1038        )));
1039    }
1040    if value > MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
1041        let unscaled_value =
1042            format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
1043        let unscaled_max_value = format_decimal_str(
1044            &MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize].to_string(),
1045            precision.into(),
1046            scale,
1047        );
1048        Err(ArrowError::InvalidArgumentError(format!(
1049            "{unscaled_value} is too large to store in a Decimal128 of precision {precision}. Max is {}",
1050            unscaled_max_value
1051        )))
1052    } else if value < MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
1053        let unscaled_value =
1054            format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
1055        let unscaled_min_value = format_decimal_str(
1056            &MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize].to_string(),
1057            precision.into(),
1058            scale,
1059        );
1060        Err(ArrowError::InvalidArgumentError(format!(
1061            "{unscaled_value} is too small to store in a Decimal128 of precision {precision}. Min is {}",
1062            unscaled_min_value
1063        )))
1064    } else {
1065        Ok(())
1066    }
1067}
1068
1069/// Returns true if the specified `i128` value can be properly
1070/// interpreted as a [`Decimal128`] number with precision `precision`
1071///
1072/// [`Decimal128`]: arrow_schema::DataType::Decimal128
1073#[inline]
1074pub fn is_validate_decimal_precision(value: i128, precision: u8) -> bool {
1075    precision <= DECIMAL128_MAX_PRECISION
1076        && value >= MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1077        && value <= MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1078}
1079
1080/// Validates that the specified `i256` of value can be properly
1081/// interpreted as a [`Decimal256`] number with precision `precision`
1082///
1083/// [`Decimal256`]: arrow_schema::DataType::Decimal256
1084#[inline]
1085pub fn validate_decimal256_precision(
1086    value: i256,
1087    precision: u8,
1088    scale: i8,
1089) -> Result<(), ArrowError> {
1090    if precision > DECIMAL256_MAX_PRECISION {
1091        return Err(ArrowError::InvalidArgumentError(format!(
1092            "Max precision of a Decimal256 is {DECIMAL256_MAX_PRECISION}, but got {precision}",
1093        )));
1094    }
1095
1096    if value > MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
1097        let unscaled_value =
1098            format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
1099        let unscaled_max_value = format_decimal_str(
1100            &MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize].to_string(),
1101            precision.into(),
1102            scale,
1103        );
1104        Err(ArrowError::InvalidArgumentError(format!(
1105            "{unscaled_value} is too large to store in a Decimal256 of precision {precision}. Max is {}",
1106            unscaled_max_value
1107        )))
1108    } else if value < MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
1109        let unscaled_value =
1110            format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
1111        let unscaled_min_value = format_decimal_str(
1112            &MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize].to_string(),
1113            precision.into(),
1114            scale,
1115        );
1116        Err(ArrowError::InvalidArgumentError(format!(
1117            "{unscaled_value} is too small to store in a Decimal256 of precision {precision}. Min is {}",
1118            unscaled_min_value
1119        )))
1120    } else {
1121        Ok(())
1122    }
1123}
1124
1125/// Return true if the specified `i256` value can be properly
1126/// interpreted as a [`Decimal256`] number with precision `precision`
1127///
1128/// [`Decimal256`]: arrow_schema::DataType::Decimal256
1129#[inline]
1130pub fn is_validate_decimal256_precision(value: i256, precision: u8) -> bool {
1131    precision <= DECIMAL256_MAX_PRECISION
1132        && value >= MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1133        && value <= MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1134}
1135
1136#[inline]
1137/// Formats a decimal string given the precision and scale.
1138pub fn format_decimal_str(value_str: &str, precision: usize, scale: i8) -> String {
1139    format_decimal_str_internal(value_str, precision, scale, true)
1140}
1141
1142// Format a decimal string given the precision and scale.
1143// If `safe_decimal` is true, the function will ensure that the output string
1144// does not exceed the specified precision.
1145fn format_decimal_str_internal(
1146    value_str: &str,
1147    precision: usize,
1148    scale: i8,
1149    safe_decimal: bool,
1150) -> String {
1151    let (sign, rest) = match value_str.strip_prefix('-') {
1152        Some(stripped) => ("-", stripped),
1153        None => ("", value_str),
1154    };
1155    let bound = if safe_decimal {
1156        precision.min(rest.len()) + sign.len()
1157    } else {
1158        value_str.len()
1159    };
1160    let value_str = &value_str[0..bound];
1161
1162    if scale == 0 {
1163        value_str.to_string()
1164    } else if scale < 0 {
1165        let padding = value_str.len() + scale.unsigned_abs() as usize;
1166        format!("{value_str:0<padding$}")
1167    } else if rest.len() > scale as usize {
1168        // Decimal separator is in the middle of the string
1169        let (whole, decimal) = value_str.split_at(value_str.len() - scale as usize);
1170        format!("{whole}.{decimal}")
1171    } else {
1172        // String has to be padded
1173        format!("{}0.{:0>width$}", sign, rest, width = scale as usize)
1174    }
1175}
arrow_data/decimal.rs

arrow_data/
decimal.rs
