From d82b6d7109b32cdd6935c728b48761ed85f5aba3 Mon Sep 17 00:00:00 2001 From: Shanicky Chen Date: Mon, 10 Apr 2023 14:16:49 +0800 Subject: [PATCH] Remove Uint256 functionality and related code adjustments. --- proto/data.proto | 1 - src/common/src/array/arrow.rs | 1 - src/common/src/array/mod.rs | 12 +-------- src/common/src/array/num256_array.rs | 30 ++--------------------- src/common/src/hash/key.rs | 14 +---------- src/common/src/test_utils/rand_array.rs | 10 +------- src/common/src/types/mod.rs | 4 +-- src/common/src/types/num256.rs | 8 +----- src/common/src/types/to_binary.rs | 1 - src/common/src/util/value_encoding/mod.rs | 2 -- 10 files changed, 7 insertions(+), 76 deletions(-) diff --git a/proto/data.proto b/proto/data.proto index 60a5d1c1675a4..7ad636125fe44 100644 --- a/proto/data.proto +++ b/proto/data.proto @@ -100,7 +100,6 @@ enum ArrayType { JSONB = 16; SERIAL = 17; INT256 = 18; - UINT256 = 19; } message Array { diff --git a/src/common/src/array/arrow.rs b/src/common/src/array/arrow.rs index fe869ce91bcba..53d6f017d1eaf 100644 --- a/src/common/src/array/arrow.rs +++ b/src/common/src/array/arrow.rs @@ -456,7 +456,6 @@ impl From<&ListArray> for arrow_array::ListArray { |b, v| b.append_option(v), ), ArrayImpl::Int256(_a) => todo!(), - ArrayImpl::Uint256(_a) => todo!(), ArrayImpl::Bool(a) => { build(array, a, BooleanBuilder::with_capacity(a.len()), |b, v| { b.append_option(v) diff --git a/src/common/src/array/mod.rs b/src/common/src/array/mod.rs index 9fb4db25ecdb8..09d26c56d74d9 100644 --- a/src/common/src/array/mod.rs +++ b/src/common/src/array/mod.rs @@ -67,9 +67,7 @@ pub use utf8_array::*; pub use vis::{Vis, VisRef}; pub use self::error::ArrayError; -pub use crate::array::num256_array::{ - Int256Array, Int256ArrayBuilder, Uint256Array, Uint256ArrayBuilder, -}; +pub use crate::array::num256_array::{Int256Array, Int256ArrayBuilder}; use crate::buffer::Bitmap; use crate::collection::estimate_size::EstimateSize; use crate::types::*; @@ -346,7 +344,6 @@ macro_rules! for_all_variants { { Int32, int32, I32Array, I32ArrayBuilder }, { Int64, int64, I64Array, I64ArrayBuilder }, { Int256, int256, Int256Array, Int256ArrayBuilder }, - { Uint256, uint256, Uint256Array, Uint256ArrayBuilder }, { Float32, float32, F32Array, F32ArrayBuilder }, { Float64, float64, F64Array, F64ArrayBuilder }, { Utf8, utf8, Utf8Array, Utf8ArrayBuilder }, @@ -390,12 +387,6 @@ impl From for ArrayImpl { } } -impl From for ArrayImpl { - fn from(arr: Uint256Array) -> Self { - Self::Uint256(arr) - } -} - impl From for ArrayImpl { fn from(arr: BoolArray) -> Self { Self::Bool(arr) @@ -731,7 +722,6 @@ impl ArrayImpl { read_string_array::(array, cardinality)? } PbArrayType::Int256 => Int256Array::from_protobuf(array, cardinality)?, - PbArrayType::Uint256 => Uint256Array::from_protobuf(array, cardinality)?, }; Ok(array) } diff --git a/src/common/src/array/num256_array.rs b/src/common/src/array/num256_array.rs index 695b5a65369e7..001c49a92f5bd 100644 --- a/src/common/src/array/num256_array.rs +++ b/src/common/src/array/num256_array.rs @@ -15,7 +15,7 @@ use std::io::{Cursor, Read}; use std::mem::size_of; -use ethnum::{I256, U256}; +use ethnum::I256; use risingwave_pb::common::buffer::CompressionType; use risingwave_pb::common::Buffer; use risingwave_pb::data::PbArray; @@ -23,7 +23,7 @@ use risingwave_pb::data::PbArray; use crate::array::{Array, ArrayBuilder, ArrayImpl, ArrayResult}; use crate::buffer::{Bitmap, BitmapBuilder}; use crate::collection::estimate_size::EstimateSize; -use crate::types::num256::{Int256, Int256Ref, Uint256, Uint256Ref}; +use crate::types::num256::{Int256, Int256Ref}; use crate::types::Scalar; #[derive(Debug)] @@ -38,18 +38,6 @@ pub struct Int256Array { data: Vec, } -#[derive(Debug)] -pub struct Uint256ArrayBuilder { - bitmap: BitmapBuilder, - data: Vec, -} - -#[derive(Debug, Clone)] -pub struct Uint256Array { - bitmap: Bitmap, - data: Vec, -} - #[rustfmt::skip] macro_rules! impl_array_for_num256 { ( @@ -191,14 +179,6 @@ macro_rules! impl_array_for_num256 { }; } -impl_array_for_num256!( - Uint256Array, - Uint256ArrayBuilder, - Uint256, - Uint256Ref<'a>, - Uint256 -); - impl_array_for_num256!( Int256Array, Int256ArrayBuilder, @@ -207,12 +187,6 @@ impl_array_for_num256!( Int256 ); -impl EstimateSize for Uint256Array { - fn estimated_heap_size(&self) -> usize { - self.bitmap.estimated_heap_size() + self.data.capacity() * size_of::() - } -} - impl EstimateSize for Int256Array { fn estimated_heap_size(&self) -> usize { self.bitmap.estimated_heap_size() + self.data.capacity() * size_of::() diff --git a/src/common/src/hash/key.rs b/src/common/src/hash/key.rs index 2f3bd929e9e1b..956ecf9519c74 100644 --- a/src/common/src/hash/key.rs +++ b/src/common/src/hash/key.rs @@ -37,7 +37,7 @@ use crate::array::{ }; use crate::collection::estimate_size::EstimateSize; use crate::row::{OwnedRow, RowDeserializer}; -use crate::types::num256::{Int256Ref, Uint256Ref}; +use crate::types::num256::Int256Ref; use crate::types::{DataType, Date, Decimal, ScalarRef, Time, Timestamp, F32, F64}; use crate::util::hash_util::Crc32FastBuilder; use crate::util::iter_util::ZipEqFast; @@ -431,18 +431,6 @@ impl<'a> HashKeySerDe<'a> for Int256Ref<'a> { } } -impl<'a> HashKeySerDe<'a> for Uint256Ref<'a> { - type S = [u8; 32]; - - fn serialize(self) -> Self::S { - unimplemented!("HashKeySerDe cannot be implemented for non-primitive types") - } - - fn deserialize(_source: &mut R) -> Self { - unimplemented!("HashKeySerDe cannot be implemented for non-primitive types") - } -} - /// Same as str. impl<'a> HashKeySerDe<'a> for &'a [u8] { type S = Vec; diff --git a/src/common/src/test_utils/rand_array.rs b/src/common/src/test_utils/rand_array.rs index d45eebaf7572d..a8382eb0bfbe4 100644 --- a/src/common/src/test_utils/rand_array.rs +++ b/src/common/src/test_utils/rand_array.rs @@ -27,7 +27,7 @@ use rand::{Rng, SeedableRng}; use crate::array::serial_array::Serial; use crate::array::{Array, ArrayBuilder, ArrayRef, JsonbVal, ListValue, StructValue}; -use crate::types::num256::{Int256, Uint256}; +use crate::types::num256::Int256; use crate::types::{Date, Decimal, Interval, NativeType, Scalar, Time, Timestamp}; pub trait RandValue { @@ -127,14 +127,6 @@ impl RandValue for Int256 { } } -impl RandValue for Uint256 { - fn rand_value(rand: &mut R) -> Self { - let mut bytes = [0u8; 32]; - rand.fill_bytes(&mut bytes); - Uint256::from_ne_bytes(bytes) - } -} - impl RandValue for JsonbVal { fn rand_value(_rand: &mut R) -> Self { JsonbVal::dummy() diff --git a/src/common/src/types/mod.rs b/src/common/src/types/mod.rs index 9f35a305948f4..3bb333df84103 100644 --- a/src/common/src/types/mod.rs +++ b/src/common/src/types/mod.rs @@ -70,7 +70,7 @@ use crate::array::{ StructValue, }; use crate::error::Result as RwResult; -use crate::types::num256::{Int256, Int256Ref, Uint256, Uint256Ref}; +use crate::types::num256::{Int256, Int256Ref}; pub type F32 = ordered_float::OrderedFloat; pub type F64 = ordered_float::OrderedFloat; @@ -502,7 +502,6 @@ macro_rules! for_all_scalar_variants { { Int32, int32, i32, i32 }, { Int64, int64, i64, i64 }, { Int256, int256, Int256, Int256Ref<'scalar> }, - { Uint256, uint256, Uint256, Uint256Ref<'scalar> }, { Serial, serial, Serial, Serial }, { Float32, float32, F32, F32 }, { Float64, float64, F64, F64 }, @@ -1034,7 +1033,6 @@ impl ScalarRefImpl<'_> { Self::Int32(v) => v.serialize(ser)?, Self::Int64(v) => v.serialize(ser)?, Self::Int256(v) => v.serialize(ser)?, - Self::Uint256(v) => v.serialize(ser)?, Self::Serial(v) => v.serialize(ser)?, Self::Float32(v) => v.serialize(ser)?, Self::Float64(v) => v.serialize(ser)?, diff --git a/src/common/src/types/num256.rs b/src/common/src/types/num256.rs index d05b610dc3e00..2fb5771a1af9f 100644 --- a/src/common/src/types/num256.rs +++ b/src/common/src/types/num256.rs @@ -17,7 +17,7 @@ use std::hash::Hasher; use std::mem; use bytes::Bytes; -use ethnum::{I256, U256}; +use ethnum::I256; use postgres_types::{ToSql, Type}; use risingwave_pb::data::ArrayType; use serde::{Serialize, Serializer}; @@ -27,11 +27,6 @@ use crate::array::ArrayResult; use crate::types::to_binary::ToBinary; use crate::types::{to_text, DataType, Scalar, ScalarRef}; -#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Default, Hash)] -pub struct Uint256(Box); -#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd)] -pub struct Uint256Ref<'a>(pub &'a U256); - #[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Default, Hash)] pub struct Int256(Box); #[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd)] @@ -141,5 +136,4 @@ macro_rules! impl_common_for_num256 { }; } -impl_common_for_num256!(Uint256, Uint256Ref<'a>, U256, Uint256); impl_common_for_num256!(Int256, Int256Ref<'a>, I256, Int256); diff --git a/src/common/src/types/to_binary.rs b/src/common/src/types/to_binary.rs index 43ddf4704bf3b..42cc191997ab4 100644 --- a/src/common/src/types/to_binary.rs +++ b/src/common/src/types/to_binary.rs @@ -84,7 +84,6 @@ impl ToBinary for ScalarRefImpl<'_> { ScalarRefImpl::Int32(v) => v.to_binary_with_type(ty), ScalarRefImpl::Int64(v) => v.to_binary_with_type(ty), ScalarRefImpl::Int256(v) => v.to_binary_with_type(ty), - ScalarRefImpl::Uint256(v) => v.to_binary_with_type(ty), ScalarRefImpl::Serial(v) => v.to_binary_with_type(ty), ScalarRefImpl::Float32(v) => v.to_binary_with_type(ty), ScalarRefImpl::Float64(v) => v.to_binary_with_type(ty), diff --git a/src/common/src/util/value_encoding/mod.rs b/src/common/src/util/value_encoding/mod.rs index ebbb6f2d35b13..5ed41a5d1c745 100644 --- a/src/common/src/util/value_encoding/mod.rs +++ b/src/common/src/util/value_encoding/mod.rs @@ -213,7 +213,6 @@ fn serialize_scalar(value: ScalarRefImpl<'_>, buf: &mut impl BufMut) { ScalarRefImpl::Int32(v) => buf.put_i32_le(v), ScalarRefImpl::Int64(v) => buf.put_i64_le(v), ScalarRefImpl::Int256(v) => buf.put_slice(&v.to_le_bytes()), - ScalarRefImpl::Uint256(v) => buf.put_slice(&v.to_le_bytes()), ScalarRefImpl::Serial(v) => buf.put_i64_le(v.into_inner()), ScalarRefImpl::Float32(v) => buf.put_f32_le(v.into_inner()), ScalarRefImpl::Float64(v) => buf.put_f64_le(v.into_inner()), @@ -241,7 +240,6 @@ fn estimate_serialize_scalar_size(value: ScalarRefImpl<'_>) -> usize { ScalarRefImpl::Int32(_) => 4, ScalarRefImpl::Int64(_) => 8, ScalarRefImpl::Int256(_) => 32, - ScalarRefImpl::Uint256(_) => 32, ScalarRefImpl::Serial(_) => 8, ScalarRefImpl::Float32(_) => 4, ScalarRefImpl::Float64(_) => 8,