Google Git
Sign in
apache / arrow-rs / HEAD / . / arrow-data / src / decimal.rs
blob: 2c997753bd5f558a0de7c623235ce5e182b4b32f [file] [log] [blame]
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
//! Maximum and minimum values for [`Decimal256`], [`Decimal128`], [`Decimal64`] and [`Decimal32`].
//!
//! Also provides functions to validate if a given decimal value is within
//! the valid range of the decimal type.
//!
//! [`Decimal32`]: arrow_schema::DataType::Decimal32
//! [`Decimal64`]: arrow_schema::DataType::Decimal64
//! [`Decimal128`]: arrow_schema::DataType::Decimal128
//! [`Decimal256`]: arrow_schema::DataType::Decimal256
use arrow_buffer::i256;
use arrow_schema::ArrowError;
pub use arrow_schema::{
DECIMAL_DEFAULT_SCALE, DECIMAL32_DEFAULT_SCALE, DECIMAL32_MAX_PRECISION, DECIMAL32_MAX_SCALE,
DECIMAL64_DEFAULT_SCALE, DECIMAL64_MAX_PRECISION, DECIMAL64_MAX_SCALE,
DECIMAL128_MAX_PRECISION, DECIMAL128_MAX_SCALE, DECIMAL256_MAX_PRECISION, DECIMAL256_MAX_SCALE,
};
/// `MAX_DECIMAL256_FOR_EACH_PRECISION[p]` holds the maximum [`i256`] value that can
/// be stored in a [`Decimal256`] value of precision `p`.
///
/// # Notes
///
/// Each element is the max value of signed 256-bit integer for the specified
/// precision which is encoded to the 32-byte width format of little-endian.
///
/// The first element is unused and is inserted so that we can look up using
/// precision as the index without the need to subtract 1 first.
///
/// # Example
/// ```
/// # use arrow_buffer::i256;
/// # use arrow_data::decimal::MAX_DECIMAL256_FOR_EACH_PRECISION;
/// assert_eq!(MAX_DECIMAL256_FOR_EACH_PRECISION[3], i256::from(999));
/// ```
///
/// [`Decimal256`]: arrow_schema::DataType::Decimal256
/// [`i256`]: arrow_buffer::i256
pub const MAX_DECIMAL256_FOR_EACH_PRECISION: [i256; 77] = [
i256::from_i128(0_i128), // unused first element
i256::from_le_bytes([
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,
0, 0,
]),
i256::from_le_bytes([
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,
0, 0,
]),
i256::from_le_bytes([
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,
0, 0,
]),
i256::from_le_bytes([
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,
0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 160, 237, 204, 206, 27, 194, 211, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 227, 210, 12, 200, 220, 210, 183, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 231, 60, 128, 208, 159, 60, 46, 59, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
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,
0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 159, 202, 23, 114, 109, 174, 15, 30, 67, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 63, 234, 237, 116, 70, 208, 156, 44, 159, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 127, 38, 75, 145, 192, 34, 32, 190, 55, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 128, 239, 172, 133, 91, 65, 109, 45, 238, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 9, 91, 193, 56, 147, 141, 68, 198, 77, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 99, 142, 141, 55, 192, 135, 173, 190, 9, 237, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 231, 143, 135, 43, 130, 77, 199, 114, 97, 66, 19, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 15, 159, 75, 179, 21, 7, 201, 123, 206, 151, 192, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 159, 54, 244, 0, 217, 70, 218, 213, 16, 238, 133, 7, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 63, 34, 138, 9, 122, 196, 134, 90, 168, 76, 59, 75, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 127, 86, 101, 95, 196, 172, 67, 137, 147, 254, 80, 240, 2, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 96, 245, 185, 171, 191, 164, 92, 195, 241, 41, 99, 29, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 201, 149, 67, 181, 124, 111, 158, 161, 113, 163, 223, 37, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 227, 217, 163, 20, 223, 90, 48, 80, 112, 98, 188, 122, 11, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 231, 130, 102, 206, 182, 140, 227, 33, 99, 216, 91, 203, 114, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 15, 29, 1, 16, 36, 127, 227, 82, 223, 115, 150, 241, 123, 4, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 159, 34, 11, 160, 104, 247, 226, 60, 185, 134, 224, 111, 215, 44,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 63, 90, 111, 64, 22, 170, 221, 96, 60, 67, 197, 94, 106, 192, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 127, 134, 89, 132, 222, 164, 168, 200, 91, 160, 180, 179, 39, 132,
17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 64, 127, 43, 177, 112, 150, 214, 149, 67, 14, 5, 141, 41,
175, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 137, 248, 178, 235, 102, 224, 97, 218, 163, 142, 50, 130,
159, 215, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 99, 181, 253, 52, 5, 196, 210, 135, 102, 146, 249, 21, 59,
108, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 231, 21, 233, 17, 52, 168, 59, 78, 1, 184, 191, 219, 78, 58,
172, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 15, 219, 26, 179, 8, 146, 84, 14, 13, 48, 125, 149, 20, 71,
186, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 159, 142, 12, 255, 86, 180, 77, 143, 130, 224, 227, 214, 205,
198, 70, 11, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 63, 146, 125, 246, 101, 11, 9, 153, 25, 197, 230, 100, 10,
196, 195, 112, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 127, 182, 231, 160, 251, 113, 90, 250, 255, 178, 3, 241, 103,
168, 165, 103, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 32, 13, 73, 212, 115, 136, 199, 255, 253, 36, 106, 15,
148, 120, 12, 20, 4, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 73, 131, 218, 74, 134, 84, 203, 253, 235, 113, 37, 154,
200, 181, 124, 200, 40, 0, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 227, 32, 137, 236, 62, 77, 241, 233, 55, 115, 118, 5,
214, 25, 223, 212, 151, 1, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 231, 72, 91, 61, 117, 4, 109, 35, 47, 128, 160, 54, 92,
2, 183, 80, 238, 15, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 15, 217, 144, 101, 148, 44, 66, 98, 215, 1, 69, 34, 154,
23, 38, 39, 79, 159, 0, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 159, 122, 168, 247, 203, 189, 149, 214, 105, 18, 178,
86, 5, 236, 124, 135, 23, 57, 6, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 63, 202, 148, 172, 247, 105, 217, 97, 34, 184, 244, 98,
53, 56, 225, 74, 235, 58, 62, 0, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 127, 230, 207, 189, 172, 35, 126, 210, 87, 49, 143, 221,
21, 50, 204, 236, 48, 77, 110, 2, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 0, 31, 106, 191, 100, 237, 56, 110, 237, 151, 167,
218, 244, 249, 63, 233, 3, 79, 24, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 9, 54, 37, 122, 239, 69, 57, 78, 70, 239, 139, 138,
144, 195, 127, 28, 39, 22, 243, 0, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 99, 28, 116, 197, 90, 187, 60, 14, 191, 88, 119,
105, 165, 163, 253, 28, 135, 221, 126, 9, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 231, 27, 137, 182, 139, 81, 95, 142, 118, 119, 169,
30, 118, 100, 232, 33, 71, 167, 244, 94, 0, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 15, 23, 91, 33, 117, 47, 185, 143, 161, 170, 158,
50, 157, 236, 19, 83, 199, 136, 142, 181, 3, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 159, 230, 142, 77, 147, 218, 59, 157, 79, 170, 50,
250, 35, 62, 199, 62, 201, 87, 145, 23, 37, 0, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 63, 2, 149, 7, 193, 137, 86, 36, 28, 167, 250, 197,
103, 109, 200, 115, 220, 109, 173, 235, 114, 1, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 127, 22, 210, 75, 138, 97, 97, 107, 25, 135, 202,
187, 13, 70, 212, 133, 156, 74, 198, 52, 125, 14, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 255, 224, 52, 246, 102, 207, 205, 49, 254, 70, 233,
85, 137, 188, 74, 58, 29, 234, 190, 15, 228, 144, 0, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 255, 201, 16, 158, 5, 26, 10, 242, 237, 197, 28,
91, 93, 93, 235, 70, 36, 37, 117, 157, 232, 168, 5, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 255, 227, 167, 44, 56, 4, 101, 116, 75, 187, 31,
143, 165, 165, 49, 197, 106, 115, 147, 38, 22, 153, 56, 0,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 255, 231, 142, 190, 49, 42, 242, 139, 242, 80, 61,
151, 119, 120, 240, 179, 43, 130, 194, 129, 221, 250, 53, 2,
]),
i256::from_le_bytes([
255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 149, 113, 241, 165, 117, 119, 121, 41,
101, 232, 171, 180, 100, 7, 181, 21, 153, 17, 167, 204, 27, 22,
]),
];
/// `MIN_DECIMAL256_FOR_EACH_PRECISION[p]` holds the minimum [`i256`] value that can
/// be stored in a [`Decimal256`] value of precision `p`.
///
/// # Notes
///
/// Each element is the min value of signed 256-bit integer for the specified precision which
/// is encoded to the 76-byte width format of little-endian.
///
/// The first element is unused and is inserted so that we can look up using
/// precision as the index without the need to subtract 1 first.
/// # Example
/// ```
/// # use arrow_buffer::i256;
/// # use arrow_data::decimal::MIN_DECIMAL256_FOR_EACH_PRECISION;
/// assert_eq!(MIN_DECIMAL256_FOR_EACH_PRECISION[3], i256::from(-999));
/// ```
///
/// [`i256`]: arrow_buffer::i256
/// [`Decimal256`]: arrow_schema::DataType::Decimal256
pub const MIN_DECIMAL256_FOR_EACH_PRECISION: [i256; 77] = [
i256::from_i128(0_i128), // unused first element
i256::from_le_bytes([
247, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
157, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
25, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
241, 216, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
97, 121, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
193, 189, 240, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
129, 105, 103, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 31, 10, 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 54, 101, 196, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 28, 244, 171, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 24, 137, 183, 232, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 240, 90, 43, 23, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 96, 141, 177, 231, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 192, 133, 239, 12, 165, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 128, 57, 91, 129, 114, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 63, 144, 13, 121, 220, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 118, 162, 135, 186, 156, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 156, 88, 76, 73, 31, 242, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 24, 118, 251, 220, 56, 117, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 240, 156, 210, 161, 56, 148, 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 96, 33, 58, 82, 54, 202, 201, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 192, 77, 69, 54, 31, 230, 225, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 128, 9, 181, 30, 56, 253, 210, 234, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 95, 18, 51, 49, 228, 61, 44, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 182, 183, 254, 235, 233, 106, 186, 247, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 28, 45, 243, 55, 35, 45, 72, 173, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 24, 195, 127, 47, 96, 195, 209, 196, 252, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 240, 158, 253, 218, 193, 161, 49, 176, 223, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 96, 53, 232, 141, 146, 81, 240, 225, 188, 254, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 192, 21, 18, 139, 185, 47, 99, 211, 96, 243, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 128, 217, 180, 110, 63, 221, 223, 65, 200, 129, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 127, 16, 83, 122, 164, 190, 146, 210, 17, 251, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 246, 164, 62, 199, 108, 114, 187, 57, 178, 206, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 156, 113, 114, 200, 63, 120, 82, 65, 246, 18, 254, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 24, 112, 120, 212, 125, 178, 56, 141, 158, 189, 236, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 240, 96, 180, 76, 234, 248, 54, 132, 49, 104, 63, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 96, 201, 11, 255, 38, 185, 37, 42, 239, 17, 122, 248, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 192, 221, 117, 246, 133, 59, 121, 165, 87, 179, 196, 180, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 128, 169, 154, 160, 59, 83, 188, 118, 108, 1, 175, 15, 253, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 159, 10, 70, 84, 64, 91, 163, 60, 14, 214, 156, 226, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 54, 106, 188, 74, 131, 144, 97, 94, 142, 92, 32, 218, 254, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 28, 38, 92, 235, 32, 165, 207, 175, 143, 157, 67, 133, 244, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 24, 125, 153, 49, 73, 115, 28, 222, 156, 39, 164, 52, 141, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 240, 226, 254, 239, 219, 128, 28, 173, 32, 140, 105, 14, 132, 251, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 96, 221, 244, 95, 151, 8, 29, 195, 70, 121, 31, 144, 40, 211, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 192, 165, 144, 191, 233, 85, 34, 159, 195, 188, 58, 161, 149, 63, 254, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 128, 121, 166, 123, 33, 91, 87, 55, 164, 95, 75, 76, 216, 123, 238, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 191, 128, 212, 78, 143, 105, 41, 106, 188, 241, 250, 114, 214, 80, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 118, 7, 77, 20, 153, 31, 158, 37, 92, 113, 205, 125, 96, 40, 249, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 156, 74, 2, 203, 250, 59, 45, 120, 153, 109, 6, 234, 196, 147, 187, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 24, 234, 22, 238, 203, 87, 196, 177, 254, 71, 64, 36, 177, 197, 83, 253,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 240, 36, 229, 76, 247, 109, 171, 241, 242, 207, 130, 106, 235, 184, 69,
229, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 96, 113, 243, 0, 169, 75, 178, 112, 125, 31, 28, 41, 50, 57, 185, 244,
254, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 192, 109, 130, 9, 154, 244, 246, 102, 230, 58, 25, 155, 245, 59, 60, 143,
245, 255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 128, 73, 24, 95, 4, 142, 165, 5, 0, 77, 252, 14, 152, 87, 90, 152, 151,
255, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 223, 242, 182, 43, 140, 119, 56, 0, 2, 219, 149, 240, 107, 135, 243,
235, 251, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 182, 124, 37, 181, 121, 171, 52, 2, 20, 142, 218, 101, 55, 74, 131,
55, 215, 255, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 28, 223, 118, 19, 193, 178, 14, 22, 200, 140, 137, 250, 41, 230, 32,
43, 104, 254, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 24, 183, 164, 194, 138, 251, 146, 220, 208, 127, 95, 201, 163, 253,
72, 175, 17, 240, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 240, 38, 111, 154, 107, 211, 189, 157, 40, 254, 186, 221, 101, 232,
217, 216, 176, 96, 255, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 96, 133, 87, 8, 52, 66, 106, 41, 150, 237, 77, 169, 250, 19, 131, 120,
232, 198, 249, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 192, 53, 107, 83, 8, 150, 38, 158, 221, 71, 11, 157, 202, 199, 30,
181, 20, 197, 193, 255, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 128, 25, 48, 66, 83, 220, 129, 45, 168, 206, 112, 34, 234, 205, 51,
19, 207, 178, 145, 253, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 255, 224, 149, 64, 155, 18, 199, 145, 18, 104, 88, 37, 11, 6, 192,
22, 252, 176, 231, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 246, 201, 218, 133, 16, 186, 198, 177, 185, 16, 116, 117, 111, 60,
128, 227, 216, 233, 12, 255, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 156, 227, 139, 58, 165, 68, 195, 241, 64, 167, 136, 150, 90, 92, 2,
227, 120, 34, 129, 246, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 24, 228, 118, 73, 116, 174, 160, 113, 137, 136, 86, 225, 137, 155,
23, 222, 184, 88, 11, 161, 255, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 240, 232, 164, 222, 138, 208, 70, 112, 94, 85, 97, 205, 98, 19,
236, 172, 56, 119, 113, 74, 252, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 96, 25, 113, 178, 108, 37, 196, 98, 176, 85, 205, 5, 220, 193, 56,
193, 54, 168, 110, 232, 218, 255, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 192, 253, 106, 248, 62, 118, 169, 219, 227, 88, 5, 58, 152, 146,
55, 140, 35, 146, 82, 20, 141, 254, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 128, 233, 45, 180, 117, 158, 158, 148, 230, 120, 53, 68, 242, 185,
43, 122, 99, 181, 57, 203, 130, 241, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 0, 31, 203, 9, 153, 48, 50, 206, 1, 185, 22, 170, 118, 67, 181,
197, 226, 21, 65, 240, 27, 111, 255, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 0, 54, 239, 97, 250, 229, 245, 13, 18, 58, 227, 164, 162, 162, 20,
185, 219, 218, 138, 98, 23, 87, 250, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 0, 28, 88, 211, 199, 251, 154, 139, 180, 68, 224, 112, 90, 90, 206,
58, 149, 140, 108, 217, 233, 102, 199, 255,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 0, 24, 113, 65, 206, 213, 13, 116, 13, 175, 194, 104, 136, 135, 15,
76, 212, 125, 61, 126, 34, 5, 202, 253,
]),
i256::from_le_bytes([
1, 0, 0, 0, 0, 0, 0, 0, 0, 240, 106, 142, 14, 90, 138, 136, 134, 214, 154, 23, 84, 75, 155,
248, 74, 234, 102, 238, 88, 51, 228, 233,
]),
];
/// `MAX_DECIMAL_FOR_EACH_PRECISION[p-1]` holds the maximum `i128` value that can
/// be stored in a [`Decimal128`] value of precision `p`
///
/// [`Decimal128`]: arrow_schema::DataType::Decimal128
#[deprecated(
since = "54.1.0",
note = "Use MAX_DECIMAL128_FOR_EACH_PRECISION (note indexes are different)"
)]
#[allow(dead_code)] // no longer used but is part of our public API
pub const MAX_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
9,
99,
999,
9999,
99999,
999999,
9999999,
99999999,
999999999,
9999999999,
99999999999,
999999999999,
9999999999999,
99999999999999,
999999999999999,
9999999999999999,
99999999999999999,
999999999999999999,
9999999999999999999,
99999999999999999999,
999999999999999999999,
9999999999999999999999,
99999999999999999999999,
999999999999999999999999,
9999999999999999999999999,
99999999999999999999999999,
999999999999999999999999999,
9999999999999999999999999999,
99999999999999999999999999999,
999999999999999999999999999999,
9999999999999999999999999999999,
99999999999999999999999999999999,
999999999999999999999999999999999,
9999999999999999999999999999999999,
99999999999999999999999999999999999,
999999999999999999999999999999999999,
9999999999999999999999999999999999999,
99999999999999999999999999999999999999,
];
/// `MIN_DECIMAL_FOR_EACH_PRECISION[p-1]` holds the minimum `i128` value that can
/// be stored in a [`Decimal128`] value of precision `p`
///
/// [`Decimal128`]: arrow_schema::DataType::Decimal128
#[allow(dead_code)] // no longer used but is part of our public API
#[deprecated(
since = "54.1.0",
note = "Use MIN_DECIMAL128_FOR_EACH_PRECISION (note indexes are different)"
)]
pub const MIN_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
-9,
-99,
-999,
-9999,
-99999,
-999999,
-9999999,
-99999999,
-999999999,
-9999999999,
-99999999999,
-999999999999,
-9999999999999,
-99999999999999,
-999999999999999,
-9999999999999999,
-99999999999999999,
-999999999999999999,
-9999999999999999999,
-99999999999999999999,
-999999999999999999999,
-9999999999999999999999,
-99999999999999999999999,
-999999999999999999999999,
-9999999999999999999999999,
-99999999999999999999999999,
-999999999999999999999999999,
-9999999999999999999999999999,
-99999999999999999999999999999,
-999999999999999999999999999999,
-9999999999999999999999999999999,
-99999999999999999999999999999999,
-999999999999999999999999999999999,
-9999999999999999999999999999999999,
-99999999999999999999999999999999999,
-999999999999999999999999999999999999,
-9999999999999999999999999999999999999,
-99999999999999999999999999999999999999,
];
/// `MAX_DECIMAL128_FOR_EACH_PRECISION[p]` holds the maximum `i128` value that can
/// be stored in [`Decimal128`] value of precision `p`.
///
/// # Notes
///
/// The first element is unused and is inserted so that we can look up using
/// precision as the index without the need to subtract 1 first.
///
/// # Example
/// ```
/// # use arrow_data::decimal::MAX_DECIMAL128_FOR_EACH_PRECISION;
/// assert_eq!(MAX_DECIMAL128_FOR_EACH_PRECISION[3], 999);
/// ```
///
/// [`Decimal128`]: arrow_schema::DataType::Decimal128
pub const MAX_DECIMAL128_FOR_EACH_PRECISION: [i128; 39] = [
0, // unused first element
9,
99,
999,
9999,
99999,
999999,
9999999,
99999999,
999999999,
9999999999,
99999999999,
999999999999,
9999999999999,
99999999999999,
999999999999999,
9999999999999999,
99999999999999999,
999999999999999999,
9999999999999999999,
99999999999999999999,
999999999999999999999,
9999999999999999999999,
99999999999999999999999,
999999999999999999999999,
9999999999999999999999999,
99999999999999999999999999,
999999999999999999999999999,
9999999999999999999999999999,
99999999999999999999999999999,
999999999999999999999999999999,
9999999999999999999999999999999,
99999999999999999999999999999999,
999999999999999999999999999999999,
9999999999999999999999999999999999,
99999999999999999999999999999999999,
999999999999999999999999999999999999,
9999999999999999999999999999999999999,
99999999999999999999999999999999999999,
];
/// `MIN_DECIMAL_FOR_EACH_PRECISION[p]` holds the minimum `i128` value that can
/// be stored in a [`Decimal128`] value of precision `p`.
///
/// # Notes
///
/// The first element is unused and is inserted so that we can look up using
/// precision as the index without the need to subtract 1 first.
///
/// # Example
/// ```
/// # use arrow_data::decimal::MIN_DECIMAL128_FOR_EACH_PRECISION;
/// assert_eq!(MIN_DECIMAL128_FOR_EACH_PRECISION[3], -999);
/// ```
///
/// [`Decimal128`]: arrow_schema::DataType::Decimal128
pub const MIN_DECIMAL128_FOR_EACH_PRECISION: [i128; 39] = [
0, // unused first element
-9,
-99,
-999,
-9999,
-99999,
-999999,
-9999999,
-99999999,
-999999999,
-9999999999,
-99999999999,
-999999999999,
-9999999999999,
-99999999999999,
-999999999999999,
-9999999999999999,
-99999999999999999,
-999999999999999999,
-9999999999999999999,
-99999999999999999999,
-999999999999999999999,
-9999999999999999999999,
-99999999999999999999999,
-999999999999999999999999,
-9999999999999999999999999,
-99999999999999999999999999,
-999999999999999999999999999,
-9999999999999999999999999999,
-99999999999999999999999999999,
-999999999999999999999999999999,
-9999999999999999999999999999999,
-99999999999999999999999999999999,
-999999999999999999999999999999999,
-9999999999999999999999999999999999,
-99999999999999999999999999999999999,
-999999999999999999999999999999999999,
-9999999999999999999999999999999999999,
-99999999999999999999999999999999999999,
];
/// `MAX_DECIMAL64_FOR_EACH_PRECISION[p]` holds the maximum `i64` value that can
/// be stored in [`Decimal64`] value of precision `p`.
///
/// # Notes
///
/// The first element is unused and is inserted so that we can look up using
/// precision as the index without the need to subtract 1 first.
///
/// # Example
/// ```
/// # use arrow_data::decimal::MAX_DECIMAL64_FOR_EACH_PRECISION;
/// assert_eq!(MAX_DECIMAL64_FOR_EACH_PRECISION[3], 999);
/// ```
///
/// [`Decimal64`]: arrow_schema::DataType::Decimal64
pub const MAX_DECIMAL64_FOR_EACH_PRECISION: [i64; 19] = [
0, // unused first element
9,
99,
999,
9999,
99999,
999999,
9999999,
99999999,
999999999,
9999999999,
99999999999,
999999999999,
9999999999999,
99999999999999,
999999999999999,
9999999999999999,
99999999999999999,
999999999999999999,
];
/// `MIN_DECIMAL64_FOR_EACH_PRECISION[p]` holds the minimum `i64` value that can
/// be stored in a [`Decimal64`] value of precision `p`.
///
/// # Notes
///
/// The first element is unused and is inserted so that we can look up using
/// precision as the index without the need to subtract 1 first.
///
/// # Example
/// ```
/// # use arrow_data::decimal::MIN_DECIMAL64_FOR_EACH_PRECISION;
/// assert_eq!(MIN_DECIMAL64_FOR_EACH_PRECISION[3], -999);
/// ```
///
/// [`Decimal64`]: arrow_schema::DataType::Decimal64
pub const MIN_DECIMAL64_FOR_EACH_PRECISION: [i64; 19] = [
0, // unused first element
-9,
-99,
-999,
-9999,
-99999,
-999999,
-9999999,
-99999999,
-999999999,
-9999999999,
-99999999999,
-999999999999,
-9999999999999,
-99999999999999,
-999999999999999,
-9999999999999999,
-99999999999999999,
-999999999999999999,
];
/// `MAX_DECIMAL32_FOR_EACH_PRECISION[p]` holds the maximum `i32` value that can
/// be stored in [`Decimal32`] value of precision `p`.
///
/// # Notes
///
/// The first element is unused and is inserted so that we can look up using
/// precision as the index without the need to subtract 1 first.
///
/// # Example
/// ```
/// # use arrow_data::decimal::MAX_DECIMAL32_FOR_EACH_PRECISION;
/// assert_eq!(MAX_DECIMAL32_FOR_EACH_PRECISION[3], 999);
/// ```
///
/// [`Decimal32`]: arrow_schema::DataType::Decimal32
pub const MAX_DECIMAL32_FOR_EACH_PRECISION: [i32; 10] = [
0, // unused first element
9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999,
];
/// `MIN_DECIMAL32_FOR_EACH_PRECISION[p]` holds the minimum `ialue that can
/// be stored in a [`Decimal32`] value of precision `p`.
///
/// # Notes
///
/// The first element is unused and is inserted so that we can look up using
/// precision as the index without the need to subtract 1 first.
///
/// # Example
/// ```
/// # use arrow_data::decimal::MIN_DECIMAL32_FOR_EACH_PRECISION;
/// assert_eq!(MIN_DECIMAL32_FOR_EACH_PRECISION[3], -999);
/// ```
///
/// [`Decimal32`]: arrow_schema::DataType::Decimal32
pub const MIN_DECIMAL32_FOR_EACH_PRECISION: [i32; 10] = [
0, // unused first element
-9, -99, -999, -9999, -99999, -999999, -9999999, -99999999, -999999999,
];
/// Validates that the specified `i32` value can be properly
/// interpreted as a [`Decimal32`] number with precision `precision`
///
/// [`Decimal32`]: arrow_schema::DataType::Decimal32
#[inline]
pub fn validate_decimal32_precision(
value: i32,
precision: u8,
scale: i8,
) -> Result<(), ArrowError> {
if precision > DECIMAL32_MAX_PRECISION {
return Err(ArrowError::InvalidArgumentError(format!(
"Max precision of a Decimal32 is {DECIMAL32_MAX_PRECISION}, but got {precision}",
)));
}
if value > MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
let unscaled_value =
format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
let unscale_max_value = format_decimal_str(
&MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize].to_string(),
precision.into(),
scale,
);
Err(ArrowError::InvalidArgumentError(format!(
"{unscaled_value} is too large to store in a Decimal32 of precision {precision}. Max is {}",
unscale_max_value
)))
} else if value < MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize] {
let unscaled_value =
format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
let unscale_min_value = format_decimal_str(
&MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize].to_string(),
precision.into(),
scale,
);
Err(ArrowError::InvalidArgumentError(format!(
"{unscaled_value} is too small to store in a Decimal32 of precision {precision}. Min is {}",
unscale_min_value
)))
} else {
Ok(())
}
}
/// Returns true if the specified `i32` value can be properly
/// interpreted as a [`Decimal32`] number with precision `precision`
///
/// [`Decimal32`]: arrow_schema::DataType::Decimal32
#[inline]
pub fn is_validate_decimal32_precision(value: i32, precision: u8) -> bool {
precision <= DECIMAL32_MAX_PRECISION
&& value >= MIN_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
&& value <= MAX_DECIMAL32_FOR_EACH_PRECISION[precision as usize]
}
/// Validates that the specified `i64` value can be properly
/// interpreted as a [`Decimal64`] number with precision `precision`
///
/// [`Decimal64`]: arrow_schema::DataType::Decimal64
#[inline]
pub fn validate_decimal64_precision(
value: i64,
precision: u8,
scale: i8,
) -> Result<(), ArrowError> {
if precision > DECIMAL64_MAX_PRECISION {
return Err(ArrowError::InvalidArgumentError(format!(
"Max precision of a Decimal64 is {DECIMAL64_MAX_PRECISION}, but got {precision}",
)));
}
if value > MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
let unscaled_value =
format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
let unscaled_max_value = format_decimal_str(
&MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize].to_string(),
precision.into(),
scale,
);
Err(ArrowError::InvalidArgumentError(format!(
"{unscaled_value} is too large to store in a Decimal64 of precision {precision}. Max is {}",
unscaled_max_value
)))
} else if value < MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize] {
let unscaled_value =
format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
let unscaled_min_value = format_decimal_str(
&MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize].to_string(),
precision.into(),
scale,
);
Err(ArrowError::InvalidArgumentError(format!(
"{unscaled_value} is too small to store in a Decimal64 of precision {precision}. Min is {}",
unscaled_min_value
)))
} else {
Ok(())
}
}
/// Returns true if the specified `i64` value can be properly
/// interpreted as a [`Decimal64`] number with precision `precision`
///
/// [`Decimal64`]: arrow_schema::DataType::Decimal64
#[inline]
pub fn is_validate_decimal64_precision(value: i64, precision: u8) -> bool {
precision <= DECIMAL64_MAX_PRECISION
&& value >= MIN_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
&& value <= MAX_DECIMAL64_FOR_EACH_PRECISION[precision as usize]
}
/// Validates that the specified `i128` value can be properly
/// interpreted as a [`Decimal128`] number with precision `precision`
///
/// [`Decimal128`]: arrow_schema::DataType::Decimal128
#[inline]
pub fn validate_decimal_precision(value: i128, precision: u8, scale: i8) -> Result<(), ArrowError> {
if precision > DECIMAL128_MAX_PRECISION {
return Err(ArrowError::InvalidArgumentError(format!(
"Max precision of a Decimal128 is {DECIMAL128_MAX_PRECISION}, but got {precision}",
)));
}
if value > MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
let unscaled_value =
format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
let unscaled_max_value = format_decimal_str(
&MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize].to_string(),
precision.into(),
scale,
);
Err(ArrowError::InvalidArgumentError(format!(
"{unscaled_value} is too large to store in a Decimal128 of precision {precision}. Max is {}",
unscaled_max_value
)))
} else if value < MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize] {
let unscaled_value =
format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
let unscaled_min_value = format_decimal_str(
&MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize].to_string(),
precision.into(),
scale,
);
Err(ArrowError::InvalidArgumentError(format!(
"{unscaled_value} is too small to store in a Decimal128 of precision {precision}. Min is {}",
unscaled_min_value
)))
} else {
Ok(())
}
}
/// Returns true if the specified `i128` value can be properly
/// interpreted as a [`Decimal128`] number with precision `precision`
///
/// [`Decimal128`]: arrow_schema::DataType::Decimal128
#[inline]
pub fn is_validate_decimal_precision(value: i128, precision: u8) -> bool {
precision <= DECIMAL128_MAX_PRECISION
&& value >= MIN_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
&& value <= MAX_DECIMAL128_FOR_EACH_PRECISION[precision as usize]
}
/// Validates that the specified `i256` of value can be properly
/// interpreted as a [`Decimal256`] number with precision `precision`
///
/// [`Decimal256`]: arrow_schema::DataType::Decimal256
#[inline]
pub fn validate_decimal256_precision(
value: i256,
precision: u8,
scale: i8,
) -> Result<(), ArrowError> {
if precision > DECIMAL256_MAX_PRECISION {
return Err(ArrowError::InvalidArgumentError(format!(
"Max precision of a Decimal256 is {DECIMAL256_MAX_PRECISION}, but got {precision}",
)));
}
if value > MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
let unscaled_value =
format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
let unscaled_max_value = format_decimal_str(
&MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize].to_string(),
precision.into(),
scale,
);
Err(ArrowError::InvalidArgumentError(format!(
"{unscaled_value} is too large to store in a Decimal256 of precision {precision}. Max is {}",
unscaled_max_value
)))
} else if value < MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize] {
let unscaled_value =
format_decimal_str_internal(&value.to_string(), precision.into(), scale, false);
let unscaled_min_value = format_decimal_str(
&MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize].to_string(),
precision.into(),
scale,
);
Err(ArrowError::InvalidArgumentError(format!(
"{unscaled_value} is too small to store in a Decimal256 of precision {precision}. Min is {}",
unscaled_min_value
)))
} else {
Ok(())
}
}
/// Return true if the specified `i256` value can be properly
/// interpreted as a [`Decimal256`] number with precision `precision`
///
/// [`Decimal256`]: arrow_schema::DataType::Decimal256
#[inline]
pub fn is_validate_decimal256_precision(value: i256, precision: u8) -> bool {
precision <= DECIMAL256_MAX_PRECISION
&& value >= MIN_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
&& value <= MAX_DECIMAL256_FOR_EACH_PRECISION[precision as usize]
}
#[inline]
/// Formats a decimal string given the precision and scale.
pub fn format_decimal_str(value_str: &str, precision: usize, scale: i8) -> String {
format_decimal_str_internal(value_str, precision, scale, true)
}
// Format a decimal string given the precision and scale.
// If `safe_decimal` is true, the function will ensure that the output string
// does not exceed the specified precision.
fn format_decimal_str_internal(
value_str: &str,
precision: usize,
scale: i8,
safe_decimal: bool,
) -> String {
let (sign, rest) = match value_str.strip_prefix('-') {
Some(stripped) => ("-", stripped),
None => ("", value_str),
};
let bound = if safe_decimal {
precision.min(rest.len()) + sign.len()
} else {
value_str.len()
};
let value_str = &value_str[0..bound];
if scale == 0 {
value_str.to_string()
} else if scale < 0 {
let padding = value_str.len() + scale.unsigned_abs() as usize;
format!("{value_str:0<padding$}")
} else if rest.len() > scale as usize {
// Decimal separator is in the middle of the string
let (whole, decimal) = value_str.split_at(value_str.len() - scale as usize);
format!("{whole}.{decimal}")
} else {
// String has to be padded
format!("{}0.{:0>width$}", sign, rest, width = scale as usize)
}
}