ci: make string format of decimal same with http handler.

Author: youngsofun

sql/Cargo.toml

@@ -20,6 +20,7 @@ arrow-buffer = { workspace = true }
 arrow-schema = { workspace = true }
 chrono = { workspace = true }
 chrono-tz = { workspace = true }
+ethnum = "1.5.1"
 databend-client = { workspace = true }
 jsonb = { workspace = true }
 tokio-stream = { workspace = true }

sql/src/value/arrow_decoder.rs

@@ -281,13 +281,17 @@ impl TryFrom<(&ArrowField, &Arc<dyn ArrowArray>, usize, Tz)> for Value {
             }
             ArrowDataType::Decimal256(p, s) => {
                 match array.as_any().downcast_ref::<Decimal256Array>() {
-                    Some(array) => Ok(Value::Number(NumberValue::Decimal256(
-                        array.value(seq),
-                        DecimalSize {
-                            precision: *p,
-                            scale: *s as u8,
-                        },
-                    ))),
+                    Some(array) => {
+                        let v = array.value(seq);
+                        let v: i256 = unsafe { std::mem::transmute(v) };
+                        Ok(Value::Number(NumberValue::Decimal256(
+                            v,
+                            DecimalSize {
+                                precision: *p,
+                                scale: *s as u8,
+                            },
+                        )))
+                    }
                     None => Err(ConvertError::new("Decimal256", format!("{array:?}")).into()),
                 }
             }

sql/src/value/base.rs

@@ -12,10 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use arrow_buffer::i256;
 use chrono::{DateTime, FixedOffset};
 use chrono_tz::Tz;
 use databend_client::schema::{DataType, DecimalDataType, DecimalSize, NumberDataType};
+use ethnum::i256;
 
 // Thu 1970-01-01 is R.D. 719163
 pub(crate) const DAYS_FROM_CE: i32 = 719_163;

sql/src/value/format/display.rs

@@ -15,8 +15,8 @@
 use crate::_macro_internal::Value;
 use crate::value::base::{DAYS_FROM_CE, TIMESTAMP_FORMAT, TIMESTAMP_TIMEZONE_FORMAT};
 use crate::value::NumberValue;
-use arrow_buffer::i256;
 use chrono::NaiveDate;
+use ethnum::i256;
 use std::fmt::Write;
 
 impl std::fmt::Display for Value {
@@ -180,39 +180,28 @@ pub fn display_decimal_128(num: i128, scale: u8) -> String {
 pub fn display_decimal_256(num: i256, scale: u8) -> String {
     let mut buf = String::new();
     if scale == 0 {
-        write!(buf, "{num}").unwrap();
+        write!(buf, "{}", num).unwrap();
     } else {
-        let pow_scale = i256::from_i128(10i128).wrapping_pow(scale as u32);
-        let width = scale as usize;
+        let pow_scale = i256::from(10).pow(scale as u32);
         // -1/10 = 0
-        let (int_part, neg) = if num >= i256::ZERO {
-            (num / pow_scale, "")
+        if !num.is_negative() {
+            write!(
+                buf,
+                "{}.{:0>width$}",
+                num / pow_scale,
+                (num % pow_scale).wrapping_abs(),
+                width = scale as usize
+            )
         } else {
-            (-num / pow_scale, "-")
-        };
-        let frac_part = (num % pow_scale).wrapping_abs();
-
-        match frac_part.to_i128() {
-            Some(frac_part) => {
-                write!(buf, "{neg}{int_part}.{frac_part:0>width$}").unwrap();
-            }
-            None => {
-                // fractional part is too big for display,
-                // split it into two parts.
-                let pow = i256::from_i128(10i128).wrapping_pow(38);
-                let frac_high_part = frac_part / pow;
-                let frac_low_part = frac_part % pow;
-                let frac_width = (scale - 38) as usize;
-
-                write!(
-                    buf,
-                    "{neg}{int_part}.{:0>frac_width$}{}",
-                    frac_high_part.to_i128().unwrap(),
-                    frac_low_part.to_i128().unwrap(),
-                )
-                .unwrap();
-            }
+            write!(
+                buf,
+                "-{}.{:0>width$}",
+                -num / pow_scale,
+                (num % pow_scale).wrapping_abs(),
+                width = scale as usize
+            )
         }
+        .expect("display_decimal_256 should not fail");
     }
-    buf
+    String::from_utf8_lossy(buf.as_bytes()).to_string()
 }

sql/src/value/string_decoder.rs

@@ -12,20 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use super::{NumberValue, Value, DAYS_FROM_CE, TIMESTAMP_TIMEZONE_FORMAT};
 use crate::_macro_internal::Error;
 use crate::cursor_ext::{
     collect_binary_number, collect_number, BufferReadStringExt, ReadBytesExt, ReadCheckPointExt,
     ReadNumberExt,
 };
 use crate::error::{ConvertError, Result};
-use arrow_buffer::i256;
 use chrono::{DateTime, Datelike, FixedOffset, LocalResult, NaiveDate, NaiveDateTime, TimeZone};
 use chrono_tz::Tz;
 use databend_client::schema::{DataType, DecimalDataType, DecimalSize, NumberDataType};
+use ethnum::i256;
 use hex;
 use std::io::{BufRead, Cursor};
-
-use super::{NumberValue, Value, DAYS_FROM_CE, TIMESTAMP_TIMEZONE_FORMAT};
+use std::str::FromStr;
 
 const NULL_VALUE: &str = "NULL";
 const TRUE_VALUE: &str = "1";
@@ -515,7 +515,7 @@ fn parse_decimal(text: &str, size: DecimalSize) -> Result<NumberValue> {
         let digits = unsafe { std::str::from_utf8_unchecked(&digits[..precision]) };
 
         let result = if size.precision > 38 {
-            NumberValue::Decimal256(i256::from_string(digits).unwrap(), size)
+            NumberValue::Decimal256(i256::from_str(digits).unwrap(), size)
         } else {
             NumberValue::Decimal128(digits.parse::<i128>()?, size)
         };