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    DECIMAL128_MAX_PRECISION, DECIMAL128_MAX_SCALE, DECIMAL256_MAX_PRECISION, DECIMAL256_MAX_SCALE,
32    DECIMAL32_DEFAULT_SCALE, DECIMAL32_MAX_PRECISION, DECIMAL32_MAX_SCALE, DECIMAL64_DEFAULT_SCALE,
33    DECIMAL64_MAX_PRECISION, DECIMAL64_MAX_SCALE, DECIMAL_DEFAULT_SCALE,
34};
35
36/// `MAX_DECIMAL256_FOR_EACH_PRECISION[p]` holds the maximum [`i256`] value that can
37/// be stored in a [`Decimal256`] value of precision `p`.
38///
39/// # Notes
40///
41/// Each element is the max value of signed 256-bit integer for the specified
42/// precision which is encoded to the 32-byte width format of little-endian.
43///
44/// The first element is unused and is inserted so that we can look up using
45/// precision as the index without the need to subtract 1 first.
46///
47/// # Example
48/// ```
49/// # use arrow_buffer::i256;
50/// # use arrow_data::decimal::MAX_DECIMAL256_FOR_EACH_PRECISION;
51/// assert_eq!(MAX_DECIMAL256_FOR_EACH_PRECISION[3], i256::from(999));
52/// ```
53///
54/// [`Decimal256`]: arrow_schema::DataType::Decimal256
55/// [`i256`]: arrow_buffer::i256
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_DECIMAL_FOR_EACH_PRECISION[p-1]` holds the maximum `i128` value that can
692/// be stored in a [`Decimal128`] value of precision `p`
693///
694/// [`Decimal128`]: arrow_schema::DataType::Decimal128
695#[deprecated(
696    since = "54.1.0",
697    note = "Use MAX_DECIMAL128_FOR_EACH_PRECISION (note indexes are different)"
698)]
699#[allow(dead_code)] // no longer used but is part of our public API
700pub const MAX_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
701    9,
702    99,
703    999,
704    9999,
705    99999,
706    999999,
707    9999999,
708    99999999,
709    999999999,
710    9999999999,
711    99999999999,
712    999999999999,
713    9999999999999,
714    99999999999999,
715    999999999999999,
716    9999999999999999,
717    99999999999999999,
718    999999999999999999,
719    9999999999999999999,
720    99999999999999999999,
721    999999999999999999999,
722    9999999999999999999999,
723    99999999999999999999999,
724    999999999999999999999999,
725    9999999999999999999999999,
726    99999999999999999999999999,
727    999999999999999999999999999,
728    9999999999999999999999999999,
729    99999999999999999999999999999,
730    999999999999999999999999999999,
731    9999999999999999999999999999999,
732    99999999999999999999999999999999,
733    999999999999999999999999999999999,
734    9999999999999999999999999999999999,
735    99999999999999999999999999999999999,
736    999999999999999999999999999999999999,
737    9999999999999999999999999999999999999,
738    99999999999999999999999999999999999999,
739];
740
741/// `MIN_DECIMAL_FOR_EACH_PRECISION[p-1]` holds the minimum `i128` value that can
742/// be stored in a [`Decimal128`] value of precision `p`
743///
744/// [`Decimal128`]: arrow_schema::DataType::Decimal128
745#[allow(dead_code)] // no longer used but is part of our public API
746#[deprecated(
747    since = "54.1.0",
748    note = "Use MIN_DECIMAL128_FOR_EACH_PRECISION (note indexes are different)"
749)]
750pub const MIN_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
751    -9,
752    -99,
753    -999,
754    -9999,
755    -99999,
756    -999999,
757    -9999999,
758    -99999999,
759    -999999999,
760    -9999999999,
761    -99999999999,
762    -999999999999,
763    -9999999999999,
764    -99999999999999,
765    -999999999999999,
766    -9999999999999999,
767    -99999999999999999,
768    -999999999999999999,
769    -9999999999999999999,
770    -99999999999999999999,
771    -999999999999999999999,
772    -9999999999999999999999,
773    -99999999999999999999999,
774    -999999999999999999999999,
775    -9999999999999999999999999,
776    -99999999999999999999999999,
777    -999999999999999999999999999,
778    -9999999999999999999999999999,
779    -99999999999999999999999999999,
780    -999999999999999999999999999999,
781    -9999999999999999999999999999999,
782    -99999999999999999999999999999999,
783    -999999999999999999999999999999999,
784    -9999999999999999999999999999999999,
785    -99999999999999999999999999999999999,
786    -999999999999999999999999999999999999,
787    -9999999999999999999999999999999999999,
788    -99999999999999999999999999999999999999,
789];
790
791/// `MAX_DECIMAL128_FOR_EACH_PRECISION[p]` holds the maximum `i128` value that can
792/// be stored in [`Decimal128`] value of precision `p`.
793///
794/// # Notes
795///
796/// The first element is unused and is inserted so that we can look up using
797/// precision as the index without the need to subtract 1 first.
798///
799/// # Example
800/// ```
801/// # use arrow_data::decimal::MAX_DECIMAL128_FOR_EACH_PRECISION;
802/// assert_eq!(MAX_DECIMAL128_FOR_EACH_PRECISION[3], 999);
803/// ```
804///
805/// [`Decimal128`]: arrow_schema::DataType::Decimal128
806pub const MAX_DECIMAL128_FOR_EACH_PRECISION: [i128; 39] = [
807    0, // unused first element
808    9,
809    99,
810    999,
811    9999,
812    99999,
813    999999,
814    9999999,
815    99999999,
816    999999999,
817    9999999999,
818    99999999999,
819    999999999999,
820    9999999999999,
821    99999999999999,
822    999999999999999,
823    9999999999999999,
824    99999999999999999,
825    999999999999999999,
826    9999999999999999999,
827    99999999999999999999,
828    999999999999999999999,
829    9999999999999999999999,
830    99999999999999999999999,
831    999999999999999999999999,
832    9999999999999999999999999,
833    99999999999999999999999999,
834    999999999999999999999999999,
835    9999999999999999999999999999,
836    99999999999999999999999999999,
837    999999999999999999999999999999,
838    9999999999999999999999999999999,
839    99999999999999999999999999999999,
840    999999999999999999999999999999999,
841    9999999999999999999999999999999999,
842    99999999999999999999999999999999999,
843    999999999999999999999999999999999999,
844    9999999999999999999999999999999999999,
845    99999999999999999999999999999999999999,
846];
847
848/// `MIN_DECIMAL_FOR_EACH_PRECISION[p]` holds the minimum `i128` value that can
849/// be stored in a [`Decimal128`] value of precision `p`.
850///
851/// # Notes
852///
853/// The first element is unused and is inserted so that we can look up using
854/// precision as the index without the need to subtract 1 first.
855///
856/// # Example
857/// ```
858/// # use arrow_data::decimal::MIN_DECIMAL128_FOR_EACH_PRECISION;
859/// assert_eq!(MIN_DECIMAL128_FOR_EACH_PRECISION[3], -999);
860/// ```
861///
862/// [`Decimal128`]: arrow_schema::DataType::Decimal128
863pub const MIN_DECIMAL128_FOR_EACH_PRECISION: [i128; 39] = [
864    0, // unused first element
865    -9,
866    -99,
867    -999,
868    -9999,
869    -99999,
870    -999999,
871    -9999999,
872    -99999999,
873    -999999999,
874    -9999999999,
875    -99999999999,
876    -999999999999,
877    -9999999999999,
878    -99999999999999,
879    -999999999999999,
880    -9999999999999999,
881    -99999999999999999,
882    -999999999999999999,
883    -9999999999999999999,
884    -99999999999999999999,
885    -999999999999999999999,
886    -9999999999999999999999,
887    -99999999999999999999999,
888    -999999999999999999999999,
889    -9999999999999999999999999,
890    -99999999999999999999999999,
891    -999999999999999999999999999,
892    -9999999999999999999999999999,
893    -99999999999999999999999999999,
894    -999999999999999999999999999999,
895    -9999999999999999999999999999999,
896    -99999999999999999999999999999999,
897    -999999999999999999999999999999999,
898    -9999999999999999999999999999999999,
899    -99999999999999999999999999999999999,
900    -999999999999999999999999999999999999,
901    -9999999999999999999999999999999999999,
902    -99999999999999999999999999999999999999,
903];
904
905/// `MAX_DECIMAL64_FOR_EACH_PRECISION[p]` holds the maximum `i64` value that can
906/// be stored in [`Decimal64`] value of precision `p`.
907///
908/// # Notes
909///
910/// The first element is unused and is inserted so that we can look up using
911/// precision as the index without the need to subtract 1 first.
912///
913/// # Example
914/// ```
915/// # use arrow_data::decimal::MAX_DECIMAL64_FOR_EACH_PRECISION;
916/// assert_eq!(MAX_DECIMAL64_FOR_EACH_PRECISION[3], 999);
917/// ```
918///
919/// [`Decimal64`]: arrow_schema::DataType::Decimal64
920pub const MAX_DECIMAL64_FOR_EACH_PRECISION: [i64; 19] = [
921    0, // unused first element
922    9,
923    99,
924    999,
925    9999,
926    99999,
927    999999,
928    9999999,
929    99999999,
930    999999999,
931    9999999999,
932    99999999999,
933    999999999999,
934    9999999999999,
935    99999999999999,
936    999999999999999,
937    9999999999999999,
938    99999999999999999,
939    999999999999999999,
940];
941
942/// `MIN_DECIMAL64_FOR_EACH_PRECISION[p]` holds the minimum `i64` value that can
943/// be stored in a [`Decimal64`] value of precision `p`.
944///
945/// # Notes
946///
947/// The first element is unused and is inserted so that we can look up using
948/// precision as the index without the need to subtract 1 first.
949///
950/// # Example
951/// ```
952/// # use arrow_data::decimal::MIN_DECIMAL64_FOR_EACH_PRECISION;
953/// assert_eq!(MIN_DECIMAL64_FOR_EACH_PRECISION[3], -999);
954/// ```
955///
956/// [`Decimal64`]: arrow_schema::DataType::Decimal64
957pub const MIN_DECIMAL64_FOR_EACH_PRECISION: [i64; 19] = [
958    0, // unused first element
959    -9,
960    -99,
961    -999,
962    -9999,
963    -99999,
964    -999999,
965    -9999999,
966    -99999999,
967    -999999999,
968    -9999999999,
969    -99999999999,
970    -999999999999,
971    -9999999999999,
972    -99999999999999,
973    -999999999999999,
974    -9999999999999999,
975    -99999999999999999,
976    -999999999999999999,
977];
978
979/// `MAX_DECIMAL32_FOR_EACH_PRECISION[p]` holds the maximum `i32` value that can
980/// be stored in [`Decimal32`] value of precision `p`.
981///
982/// # Notes
983///
984/// The first element is unused and is inserted so that we can look up using
985/// precision as the index without the need to subtract 1 first.
986///
987/// # Example
988/// ```
989/// # use arrow_data::decimal::MAX_DECIMAL32_FOR_EACH_PRECISION;
990/// assert_eq!(MAX_DECIMAL32_FOR_EACH_PRECISION[3], 999);
991/// ```
992///
993/// [`Decimal32`]: arrow_schema::DataType::Decimal32
994pub const MAX_DECIMAL32_FOR_EACH_PRECISION: [i32; 10] = [
995    0, // unused first element
996    9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999,
997];
998
999/// `MIN_DECIMAL32_FOR_EACH_PRECISION[p]` holds the minimum `ialue that can
1000/// be stored in a [`Decimal32`] value of precision `p`.
1001///
1002/// # Notes
1003///
1004/// The first element is unused and is inserted so that we can look up using
1005/// precision as the index without the need to subtract 1 first.
1006///
1007/// # Example
1008/// ```
1009/// # use arrow_data::decimal::MIN_DECIMAL32_FOR_EACH_PRECISION;
1010/// assert_eq!(MIN_DECIMAL32_FOR_EACH_PRECISION[3], -999);
1011/// ```
1012///
1013/// [`Decimal32`]: arrow_schema::DataType::Decimal32
1014pub const MIN_DECIMAL32_FOR_EACH_PRECISION: [i32; 10] = [
1015    0, // unused first element
1016    -9, -99, -999, -9999, -99999, -999999, -9999999, -99999999, -999999999,
1017];
1018
1019/// Validates that the specified `i32` value can be properly
1020/// interpreted as a [`Decimal32`] number with precision `precision`
1021///
1022/// [`Decimal32`]: arrow_schema::DataType::Decimal32
1023#[inline]
1024pub fn validate_decimal32_precision(value: i32, precision: u8) -> Result<(), ArrowError> {
1025    if precision > DECIMAL32_MAX_PRECISION {
1026        return Err(ArrowError::InvalidArgumentError(format!(
1027            "Max precision of a Decimal32 is {DECIMAL32_MAX_PRECISION}, but got {precision}",
1028        )));
1029    }
1030    if value > MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
1031        Err(ArrowError::InvalidArgumentError(format!(
1032            "{value} is too large to store in a Decimal32 of precision {precision}. Max is {}",
1033            MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
1034        )))
1035    } else if value < MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
1036        Err(ArrowError::InvalidArgumentError(format!(
1037            "{value} is too small to store in a Decimal32 of precision {precision}. Min is {}",
1038            MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
1039        )))
1040    } else {
1041        Ok(())
1042    }
1043}
1044
1045/// Returns true if the specified `i32` value can be properly
1046/// interpreted as a [`Decimal32`] number with precision `precision`
1047///
1048/// [`Decimal32`]: arrow_schema::DataType::Decimal32
1049#[inline]
1050pub fn is_validate_decimal32_precision(value: i32, precision: u8) -> bool {
1051    precision <= DECIMAL32_MAX_PRECISION
1052        && value >= MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
1053        && value <= MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
1054}
1055
1056/// Validates that the specified `i64` value can be properly
1057/// interpreted as a [`Decimal64`] number with precision `precision`
1058///
1059/// [`Decimal64`]: arrow_schema::DataType::Decimal64
1060#[inline]
1061pub fn validate_decimal64_precision(value: i64, precision: u8) -> Result<(), ArrowError> {
1062    if precision > DECIMAL64_MAX_PRECISION {
1063        return Err(ArrowError::InvalidArgumentError(format!(
1064            "Max precision of a Decimal64 is {DECIMAL64_MAX_PRECISION}, but got {precision}",
1065        )));
1066    }
1067    if value > MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
1068        Err(ArrowError::InvalidArgumentError(format!(
1069            "{value} is too large to store in a Decimal64 of precision {precision}. Max is {}",
1070            MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1071        )))
1072    } else if value < MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
1073        Err(ArrowError::InvalidArgumentError(format!(
1074            "{value} is too small to store in a Decimal64 of precision {precision}. Min is {}",
1075            MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1076        )))
1077    } else {
1078        Ok(())
1079    }
1080}
1081
1082/// Returns true if the specified `i64` value can be properly
1083/// interpreted as a [`Decimal64`] number with precision `precision`
1084///
1085/// [`Decimal64`]: arrow_schema::DataType::Decimal64
1086#[inline]
1087pub fn is_validate_decimal64_precision(value: i64, precision: u8) -> bool {
1088    precision <= DECIMAL64_MAX_PRECISION
1089        && value >= MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1090        && value <= MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
1091}
1092
1093/// Validates that the specified `i128` value can be properly
1094/// interpreted as a [`Decimal128`] number with precision `precision`
1095///
1096/// [`Decimal128`]: arrow_schema::DataType::Decimal128
1097#[inline]
1098pub fn validate_decimal_precision(value: i128, precision: u8) -> Result<(), ArrowError> {
1099    if precision > DECIMAL128_MAX_PRECISION {
1100        return Err(ArrowError::InvalidArgumentError(format!(
1101            "Max precision of a Decimal128 is {DECIMAL128_MAX_PRECISION}, but got {precision}",
1102        )));
1103    }
1104    if value > MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
1105        Err(ArrowError::InvalidArgumentError(format!(
1106            "{value} is too large to store in a Decimal128 of precision {precision}. Max is {}",
1107            MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1108        )))
1109    } else if value < MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
1110        Err(ArrowError::InvalidArgumentError(format!(
1111            "{value} is too small to store in a Decimal128 of precision {precision}. Min is {}",
1112            MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1113        )))
1114    } else {
1115        Ok(())
1116    }
1117}
1118
1119/// Returns true if the specified `i128` value can be properly
1120/// interpreted as a [`Decimal128`] number with precision `precision`
1121///
1122/// [`Decimal128`]: arrow_schema::DataType::Decimal128
1123#[inline]
1124pub fn is_validate_decimal_precision(value: i128, precision: u8) -> bool {
1125    precision <= DECIMAL128_MAX_PRECISION
1126        && value >= MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1127        && value <= MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
1128}
1129
1130/// Validates that the specified `i256` of value can be properly
1131/// interpreted as a [`Decimal256`] number with precision `precision`
1132///
1133/// [`Decimal256`]: arrow_schema::DataType::Decimal256
1134#[inline]
1135pub fn validate_decimal256_precision(value: i256, precision: u8) -> Result<(), ArrowError> {
1136    if precision > DECIMAL256_MAX_PRECISION {
1137        return Err(ArrowError::InvalidArgumentError(format!(
1138            "Max precision of a Decimal256 is {DECIMAL256_MAX_PRECISION}, but got {precision}",
1139        )));
1140    }
1141    if value > MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
1142        Err(ArrowError::InvalidArgumentError(format!(
1143            "{value:?} is too large to store in a Decimal256 of precision {precision}. Max is {:?}",
1144            MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1145        )))
1146    } else if value < MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
1147        Err(ArrowError::InvalidArgumentError(format!(
1148            "{value:?} is too small to store in a Decimal256 of precision {precision}. Min is {:?}",
1149            MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1150        )))
1151    } else {
1152        Ok(())
1153    }
1154}
1155
1156/// Return true if the specified `i256` value can be properly
1157/// interpreted as a [`Decimal256`] number with precision `precision`
1158///
1159/// [`Decimal256`]: arrow_schema::DataType::Decimal256
1160#[inline]
1161pub fn is_validate_decimal256_precision(value: i256, precision: u8) -> bool {
1162    precision <= DECIMAL256_MAX_PRECISION
1163        && value >= MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1164        && value <= MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
1165}
arrow_data/decimal.rs

arrow_data/
decimal.rs
