ydb/grpc_wrapper/raw_table_service/value/
proto.rs

1use crate::grpc_wrapper::raw_errors::RawError;
2use crate::grpc_wrapper::raw_table_service::value::r#type::{decode_err, RawType};
3use crate::grpc_wrapper::raw_table_service::value::{
4    RawColumn, RawResultSet, RawTypedValue, RawValue, RawValuePair,
5};
6use itertools::Itertools;
7use ydb_grpc::ydb_proto::value::Value as Primitive;
8use ydb_grpc::ydb_proto::Value as ProtoValue;
9
10impl TryFrom<ProtoValue> for RawValue {
11    type Error = RawError;
12
13    fn try_from(value: ProtoValue) -> Result<Self, Self::Error> {
14        use crate::grpc_wrapper::raw_table_service::value::RawValue::*;
15        use crate::grpc_wrapper::raw_table_service::value::RawVariantValue;
16
17        if let Some(simple) = value.value {
18            let res = match simple {
19                ydb_grpc::ydb_proto::value::Value::BoolValue(v) => Bool(v),
20                ydb_grpc::ydb_proto::value::Value::Int32Value(v) => Int32(v),
21                ydb_grpc::ydb_proto::value::Value::Uint32Value(v) => UInt32(v),
22                ydb_grpc::ydb_proto::value::Value::Int64Value(v) => Int64(v),
23                ydb_grpc::ydb_proto::value::Value::Uint64Value(v) => UInt64(v),
24                ydb_grpc::ydb_proto::value::Value::FloatValue(v) => Float(v),
25                ydb_grpc::ydb_proto::value::Value::DoubleValue(v) => Double(v),
26                ydb_grpc::ydb_proto::value::Value::BytesValue(v) => Bytes(v),
27                ydb_grpc::ydb_proto::value::Value::TextValue(v) => Text(v),
28                ydb_grpc::ydb_proto::value::Value::NullFlagValue(_) => NullFlag,
29                ydb_grpc::ydb_proto::value::Value::NestedValue(v) => {
30                    Variant(Box::new(RawVariantValue {
31                        value: (*v).try_into()?,
32                        index: value.variant_index,
33                    }))
34                }
35                ydb_grpc::ydb_proto::value::Value::Low128(v) => HighLow128(value.high_128, v),
36            };
37            return Ok(res);
38        };
39
40        if !value.items.is_empty() {
41            let items: Result<_, _> = value
42                .items
43                .into_iter()
44                .map(|item| item.try_into())
45                .collect();
46            return Ok(Items(items?));
47        };
48
49        if !value.pairs.is_empty() {
50            let pairs: Result<_, _> = value
51                .pairs
52                .into_iter()
53                .map(|item| item.try_into())
54                .collect();
55            return Ok(Pairs(pairs?));
56        };
57
58        decode_err("empty value item")
59    }
60}
61
62impl TryFrom<ydb_grpc::ydb_proto::ValuePair> for RawValuePair {
63    type Error = RawError;
64
65    fn try_from(value: ydb_grpc::ydb_proto::ValuePair) -> Result<Self, Self::Error> {
66        let key = if let Some(k) = value.key {
67            k
68        } else {
69            return decode_err("empty key value in proto pair");
70        };
71
72        let payload = if let Some(p) = value.payload {
73            p
74        } else {
75            return decode_err("empty payload value in proto pair");
76        };
77
78        Ok(RawValuePair {
79            key: key.try_into()?,
80            payload: payload.try_into()?,
81        })
82    }
83}
84
85impl From<RawValue> for ProtoValue {
86    fn from(v: RawValue) -> Self {
87        match v {
88            RawValue::Bool(v) => ProtoValue {
89                value: Some(Primitive::BoolValue(v)),
90                ..ProtoValue::default()
91            },
92            RawValue::Int32(v) => ProtoValue {
93                value: Some(Primitive::Int32Value(v)),
94                ..ProtoValue::default()
95            },
96            RawValue::UInt32(v) => ProtoValue {
97                value: Some(Primitive::Uint32Value(v)),
98                ..ProtoValue::default()
99            },
100            RawValue::Int64(v) => ProtoValue {
101                value: Some(Primitive::Int64Value(v)),
102                ..ProtoValue::default()
103            },
104            RawValue::UInt64(v) => ProtoValue {
105                value: Some(Primitive::Uint64Value(v)),
106                ..ProtoValue::default()
107            },
108            RawValue::HighLow128(h, l) => ProtoValue {
109                value: Some(Primitive::Low128(l)),
110                high_128: h,
111                ..ProtoValue::default()
112            },
113            RawValue::Float(v) => ProtoValue {
114                value: Some(Primitive::FloatValue(v)),
115                ..ProtoValue::default()
116            },
117            RawValue::Double(v) => ProtoValue {
118                value: Some(Primitive::DoubleValue(v)),
119                ..ProtoValue::default()
120            },
121            RawValue::Bytes(v) => ProtoValue {
122                value: Some(Primitive::BytesValue(v)),
123                ..ProtoValue::default()
124            },
125            RawValue::Text(v) => ProtoValue {
126                value: Some(Primitive::TextValue(v)),
127                ..ProtoValue::default()
128            },
129            RawValue::NullFlag => ProtoValue {
130                value: Some(Primitive::NullFlagValue(0)),
131                ..ProtoValue::default()
132            },
133            RawValue::Items(v) => ProtoValue {
134                items: v.into_iter().map(|item| item.into()).collect(),
135                ..ProtoValue::default()
136            },
137            RawValue::Pairs(v) => ProtoValue {
138                pairs: v.into_iter().map(|item| item.into()).collect(),
139                ..ProtoValue::default()
140            },
141            RawValue::Variant(v) => ProtoValue {
142                value: Some(ydb_grpc::ydb_proto::value::Value::NestedValue(Box::new(
143                    v.value.into(),
144                ))),
145                variant_index: v.index,
146                ..ProtoValue::default()
147            },
148        }
149    }
150}
151
152impl From<RawValuePair> for ydb_grpc::ydb_proto::ValuePair {
153    fn from(v: RawValuePair) -> Self {
154        Self {
155            key: Some(v.key.into()),
156            payload: Some(v.payload.into()),
157        }
158    }
159}
160
161impl From<RawTypedValue> for ydb_grpc::ydb_proto::TypedValue {
162    fn from(v: RawTypedValue) -> Self {
163        Self {
164            r#type: Some(v.r#type.into()),
165            value: Some(v.value.into()),
166        }
167    }
168}
169
170impl TryFrom<ydb_grpc::ydb_proto::TypedValue> for RawTypedValue {
171    type Error = RawError;
172
173    fn try_from(value: ydb_grpc::ydb_proto::TypedValue) -> Result<Self, Self::Error> {
174        let t = if let Some(t) = value.r#type {
175            RawType::try_from(t)?
176        } else {
177            return Err(RawError::decode_error("empty type in proto typed value"));
178        };
179
180        let v = if let Some(v) = value.value {
181            RawValue::try_from(v)?
182        } else {
183            RawValue::NullFlag
184        };
185
186        Ok(Self {
187            r#type: t,
188            value: v,
189        })
190    }
191}
192
193impl TryFrom<ydb_grpc::ydb_proto::ResultSet> for RawResultSet {
194    type Error = RawError;
195
196    fn try_from(proto_result_set: ydb_grpc::ydb_proto::ResultSet) -> Result<Self, Self::Error> {
197        let columns = proto_result_set
198            .columns
199            .into_iter()
200            .map(RawColumn::try_from)
201            .try_collect()?;
202
203        let raw_rows: Vec<RawValue> = proto_result_set
204            .rows
205            .into_iter()
206            .map(|item| item.try_into())
207            .try_collect()?;
208
209        let rows: Vec<Vec<RawValue>> = raw_rows
210            .into_iter()
211            .map(|item_row| match item_row {
212                RawValue::Items(items) => Ok(items),
213                item => Err(RawError::custom(format!(
214                    "unexpected item type while parse rawset, expect items: {item:?}"
215                ))),
216            })
217            .try_collect()?;
218
219        Ok(Self {
220            columns,
221            rows,
222            truncated: proto_result_set.truncated,
223        })
224    }
225}
226
227impl TryFrom<ydb_grpc::ydb_proto::Column> for RawColumn {
228    type Error = RawError;
229
230    fn try_from(value: ydb_grpc::ydb_proto::Column) -> Result<Self, Self::Error> {
231        let t = value
232            .r#type
233            .ok_or_else(|| RawError::custom("empty type at column description"))?;
234
235        Ok(Self {
236            name: value.name,
237            column_type: RawType::try_from(t)?,
238        })
239    }
240}
ydb/grpc_wrapper/raw_table_service/value/proto.rs

ydb/grpc_wrapper/raw_table_service/value/
proto.rs
