You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@avro.apache.org by mg...@apache.org on 2022/01/19 12:12:58 UTC
[avro] branch avro-3312-use-unsigned-int-for-index created (now e70412b)
This is an automated email from the ASF dual-hosted git repository.
mgrigorov pushed a change to branch avro-3312-use-unsigned-int-for-index
in repository https://gitbox.apache.org/repos/asf/avro.git.
at e70412b AVRO-3312: Use u32 instead of i32 for the Enum/Union's index field
This branch includes the following new commits:
new e70412b AVRO-3312: Use u32 instead of i32 for the Enum/Union's index field
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[avro] 01/01: AVRO-3312: Use u32 instead of i32 for the Enum/Union's index field
Posted by mg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mgrigorov pushed a commit to branch avro-3312-use-unsigned-int-for-index
in repository https://gitbox.apache.org/repos/asf/avro.git
commit e70412bb40d45eb741a5b6986c1b41ac1297add6
Author: Martin Tzvetanov Grigorov <mg...@apache.org>
AuthorDate: Wed Jan 19 14:12:25 2022 +0200
AVRO-3312: Use u32 instead of i32 for the Enum/Union's index field
Signed-off-by: Martin Tzvetanov Grigorov <mg...@apache.org>
---
lang/rust/src/decode.rs | 4 ++--
lang/rust/src/encode.rs | 2 +-
lang/rust/src/error.rs | 3 +++
lang/rust/src/ser.rs | 21 +++++++++------------
lang/rust/src/types.rs | 12 ++++++------
5 files changed, 21 insertions(+), 21 deletions(-)
diff --git a/lang/rust/src/decode.rs b/lang/rust/src/decode.rs
index eb9c018..70c1ba5 100644
--- a/lang/rust/src/decode.rs
+++ b/lang/rust/src/decode.rs
@@ -215,7 +215,7 @@ pub fn decode<R: Read>(schema: &Schema, reader: &mut R) -> AvroResult<Value> {
num_variants: variants.len(),
})?;
let value = decode0(variant, reader, schemas_by_name)?;
- Ok(Value::Union(index as i32, Box::new(value)))
+ Ok(Value::Union(index as u32, Box::new(value)))
}
Err(Error::ReadVariableIntegerBytes(io_err)) => {
if let ErrorKind::UnexpectedEof = io_err.kind() {
@@ -254,7 +254,7 @@ pub fn decode<R: Read>(schema: &Schema, reader: &mut R) -> AvroResult<Value> {
.map_err(|e| Error::ConvertI32ToUsize(e, raw_index))?;
if (0..=symbols.len()).contains(&index) {
let symbol = symbols[index].clone();
- Value::Enum(raw_index, symbol)
+ Value::Enum(raw_index as u32, symbol)
} else {
return Err(Error::GetEnumValue {
index,
diff --git a/lang/rust/src/encode.rs b/lang/rust/src/encode.rs
index 9a1fbef..6fc969a 100644
--- a/lang/rust/src/encode.rs
+++ b/lang/rust/src/encode.rs
@@ -123,7 +123,7 @@ pub fn encode_ref(value: &Value, schema: &Schema, buffer: &mut Vec<u8>) {
_ => error!("invalid schema type for String: {:?}", schema),
},
Value::Fixed(_, bytes) => buffer.extend(bytes),
- Value::Enum(i, _) => encode_int(*i, buffer),
+ Value::Enum(i, _) => encode_int(*i as i32, buffer),
Value::Union(idx, item) => {
if let Schema::Union(ref inner) = *schema {
let inner_schema = inner
diff --git a/lang/rust/src/error.rs b/lang/rust/src/error.rs
index f65ec72..d687eea 100644
--- a/lang/rust/src/error.rs
+++ b/lang/rust/src/error.rs
@@ -225,6 +225,9 @@ pub enum Error {
#[error("Cannot convert u64 to usize: {1}")]
ConvertU64ToUsize(#[source] std::num::TryFromIntError, u64),
+ #[error("Cannot convert u32 to usize: {1}")]
+ ConvertU32ToUsize(#[source] std::num::TryFromIntError, u32),
+
#[error("Cannot convert i64 to usize: {1}")]
ConvertI64ToUsize(#[source] std::num::TryFromIntError, i64),
diff --git a/lang/rust/src/ser.rs b/lang/rust/src/ser.rs
index 444ee20..5cff13e 100644
--- a/lang/rust/src/ser.rs
+++ b/lang/rust/src/ser.rs
@@ -142,7 +142,7 @@ impl<'b> ser::Serializer for &'b mut Serializer {
}
fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
- if v <= i32::max_value() as u32 {
+ if v <= i32::MAX as u32 {
self.serialize_i32(v as i32)
} else {
self.serialize_i64(i64::from(v))
@@ -150,7 +150,7 @@ impl<'b> ser::Serializer for &'b mut Serializer {
}
fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
- if v <= i64::max_value() as u64 {
+ if v <= i64::MAX as u64 {
self.serialize_i64(v as i64)
} else {
Err(ser::Error::custom("u64 is too large"))
@@ -203,7 +203,7 @@ impl<'b> ser::Serializer for &'b mut Serializer {
index: u32,
variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
- Ok(Value::Enum(index as i32, variant.to_string()))
+ Ok(Value::Enum(index, variant.to_string()))
}
fn serialize_newtype_struct<T: ?Sized>(
@@ -228,13 +228,10 @@ impl<'b> ser::Serializer for &'b mut Serializer {
T: Serialize,
{
Ok(Value::Record(vec![
- (
- "type".to_owned(),
- Value::Enum(index as i32, variant.to_owned()),
- ),
+ ("type".to_owned(), Value::Enum(index, variant.to_owned())),
(
"value".to_owned(),
- Value::Union(index as i32, Box::new(value.serialize(self)?)),
+ Value::Union(index, Box::new(value.serialize(self)?)),
),
]))
}
@@ -347,7 +344,7 @@ impl<'a> ser::SerializeSeq for SeqVariantSerializer<'a> {
T: Serialize,
{
self.items.push(Value::Union(
- self.index as i32,
+ self.index,
Box::new(value.serialize(&mut Serializer::default())?),
));
Ok(())
@@ -357,7 +354,7 @@ impl<'a> ser::SerializeSeq for SeqVariantSerializer<'a> {
Ok(Value::Record(vec![
(
"type".to_owned(),
- Value::Enum(self.index as i32, self.variant.to_owned()),
+ Value::Enum(self.index, self.variant.to_owned()),
),
("value".to_owned(), Value::Array(self.items)),
]))
@@ -466,11 +463,11 @@ impl<'a> ser::SerializeStructVariant for StructVariantSerializer<'a> {
Ok(Value::Record(vec![
(
"type".to_owned(),
- Value::Enum(self.index as i32, self.variant.to_owned()),
+ Value::Enum(self.index, self.variant.to_owned()),
),
(
"value".to_owned(),
- Value::Union(self.index as i32, Box::new(Value::Record(self.fields))),
+ Value::Union(self.index, Box::new(Value::Record(self.fields))),
),
]))
}
diff --git a/lang/rust/src/types.rs b/lang/rust/src/types.rs
index 77472b0..85e7341 100644
--- a/lang/rust/src/types.rs
+++ b/lang/rust/src/types.rs
@@ -64,14 +64,14 @@ pub enum Value {
/// of its corresponding schema.
/// This allows schema-less encoding, as well as schema resolution while
/// reading values.
- Enum(i32, String),
+ Enum(u32, String),
/// An `union` Avro value.
///
/// A Union is represented by the value it holds and its position in the type list
/// of its corresponding schema
/// This allows schema-less encoding, as well as schema resolution while
/// reading values.
- Union(i32, Box<Value>),
+ Union(u32, Box<Value>),
/// An `array` Avro value.
Array(Vec<Value>),
/// A `map` Avro value.
@@ -175,7 +175,7 @@ where
fn from(value: Option<T>) -> Self {
// FIXME: this is incorrect in case first type in union is not "none"
Self::Union(
- value.is_some() as i32,
+ value.is_some() as u32,
Box::new(value.map_or_else(|| Self::Null, Into::into)),
)
}
@@ -684,7 +684,7 @@ impl Value {
fn resolve_enum(self, symbols: &[String]) -> Result<Self, Error> {
let validate_symbol = |symbol: String, symbols: &[String]| {
if let Some(index) = symbols.iter().position(|item| item == &symbol) {
- Ok(Value::Enum(index as i32, symbol))
+ Ok(Value::Enum(index as u32, symbol))
} else {
Err(Error::GetEnumDefault {
symbol,
@@ -696,7 +696,7 @@ impl Value {
match self {
Value::Enum(raw_index, s) => {
let index = usize::try_from(raw_index)
- .map_err(|e| Error::ConvertI32ToUsize(e, raw_index))?;
+ .map_err(|e| Error::ConvertU32ToUsize(e, raw_index))?;
if (0..=symbols.len()).contains(&index) {
validate_symbol(s, symbols)
} else {
@@ -721,7 +721,7 @@ impl Value {
// Find the first match in the reader schema.
// FIXME: this might be wrong when the union consists of multiple same records that have different names
let (i, inner) = schema.find_schema(&v).ok_or(Error::FindUnionVariant)?;
- Ok(Value::Union(i as i32, Box::new(v.resolve(inner)?)))
+ Ok(Value::Union(i as u32, Box::new(v.resolve(inner)?)))
}
fn resolve_array(self, schema: &Schema) -> Result<Self, Error> {