Skip to main content

diesel_async/mysql_like/
row.rs

1use core::marker::PhantomData;
2use diesel::backend::Backend;
3use diesel::mysql_like::MysqlLikeBackend;
4use diesel::mysql_like::data_types::{MysqlTime, MysqlTimestampType};
5use diesel::mysql_like::{MysqlType, MysqlValue};
6use diesel::row::{PartialRow, RowIndex, RowSealed};
7use mysql_async::consts::{ColumnFlags, ColumnType};
8use mysql_async::{Column, Row, Value};
9use std::borrow::Cow;
10
11pub struct MysqlLikeRow<DB: MysqlLikeBackend>(pub(super) Row, PhantomData<DB>);
12
13impl<DB: MysqlLikeBackend> mysql_async::prelude::FromRow for MysqlLikeRow<DB> {
14    fn from_row_opt(row: Row) -> Result<Self, mysql_async::FromRowError>
15    where
16        Self: Sized,
17    {
18        Ok(Self(row, PhantomData))
19    }
20}
21
22impl<DB: MysqlLikeBackend> RowIndex<usize> for MysqlLikeRow<DB> {
23    fn idx(&self, idx: usize) -> Option<usize> {
24        if idx < self.0.columns_ref().len() {
25            Some(idx)
26        } else {
27            None
28        }
29    }
30}
31
32impl<'a, DB: MysqlLikeBackend> RowIndex<&'a str> for MysqlLikeRow<DB> {
33    fn idx(&self, idx: &'a str) -> Option<usize> {
34        self.0.columns().iter().position(|c| c.name_str() == idx)
35    }
36}
37
38impl<DB: MysqlLikeBackend> RowSealed for MysqlLikeRow<DB> {}
39
40impl<'a, DB: MysqlLikeBackend> diesel::row::Row<'a, DB> for MysqlLikeRow<DB> {
41    type InnerPartialRow = Self;
42    type Field<'b>
43        = MysqlLikeField<'b, DB>
44    where
45        Self: 'b,
46        'a: 'b;
47
48    fn field_count(&self) -> usize {
49        self.0.columns_ref().len()
50    }
51
52    fn get<'b, I>(&'b self, idx: I) -> Option<Self::Field<'b>>
53    where
54        'a: 'b,
55        Self: diesel::row::RowIndex<I>,
56    {
57        let idx = diesel::row::RowIndex::idx(self, idx)?;
58        let value = self.0.as_ref(idx)?;
59        let column = &self.0.columns_ref()[idx];
60        let buffer = match value {
61            Value::NULL => None,
62            Value::Bytes(b) => {
63                // deserialize gets the length prepended, so we just use that buffer
64                // directly
65                Some(Cow::Borrowed(b as &[_]))
66            }
67            Value::Time(neg, day, hour, minute, second, second_part) => {
68                let date = MysqlTime::new(
69                    0,
70                    0,
71                    *day as _,
72                    *hour as _,
73                    *minute as _,
74                    *second as _,
75                    *second_part as _,
76                    *neg as _,
77                    MysqlTimestampType::MYSQL_TIMESTAMP_TIME,
78                    0,
79                );
80                let buffer = date.serialize().to_vec();
81                Some(Cow::Owned(buffer))
82            }
83            Value::Date(year, month, day, hour, minute, second, second_part) => {
84                let date = MysqlTime::new(
85                    *year as _,
86                    *month as _,
87                    *day as _,
88                    *hour as _,
89                    *minute as _,
90                    *second as _,
91                    *second_part as _,
92                    false,
93                    MysqlTimestampType::MYSQL_TIMESTAMP_DATETIME,
94                    0,
95                );
96                let buffer = date.serialize().to_vec();
97                Some(Cow::Owned(buffer))
98            }
99            _t => {
100                let mut buffer = Vec::with_capacity(
101                    value
102                        .bin_len()
103                        .try_into()
104                        .expect("Failed to cast byte size to usize"),
105                );
106                mysql_common::proto::MySerialize::serialize(value, &mut buffer);
107                Some(Cow::Owned(buffer))
108            }
109        };
110        let field = MysqlLikeField {
111            value: buffer,
112            column,
113            name: column.name_str(),
114            _phantom: PhantomData,
115        };
116        Some(field)
117    }
118
119    fn partial_row(&self, range: std::ops::Range<usize>) -> PartialRow<'_, Self::InnerPartialRow> {
120        PartialRow::new::<DB>(self, range)
121    }
122}
123
124pub struct MysqlLikeField<'a, DB> {
125    value: Option<Cow<'a, [u8]>>,
126    column: &'a Column,
127    name: Cow<'a, str>,
128    _phantom: PhantomData<DB>,
129}
130
131impl<DB: MysqlLikeBackend> diesel::row::Field<'_, DB> for MysqlLikeField<'_, DB> {
132    fn field_name(&self) -> Option<&str> {
133        Some(&*self.name)
134    }
135
136    fn value(&self) -> Option<<DB as Backend>::RawValue<'_>> {
137        self.value.as_ref().map(|v| {
138            MysqlValue::new(
139                v,
140                convert_type(self.column.column_type(), self.column.flags()),
141            )
142        })
143    }
144}
145
146fn convert_type(column_type: ColumnType, column_flags: ColumnFlags) -> MysqlType {
147    match column_type {
148        ColumnType::MYSQL_TYPE_NEWDECIMAL | ColumnType::MYSQL_TYPE_DECIMAL => MysqlType::Numeric,
149        ColumnType::MYSQL_TYPE_TINY if column_flags.contains(ColumnFlags::UNSIGNED_FLAG) => {
150            MysqlType::UnsignedTiny
151        }
152        ColumnType::MYSQL_TYPE_TINY => MysqlType::Tiny,
153        ColumnType::MYSQL_TYPE_YEAR | ColumnType::MYSQL_TYPE_SHORT
154            if column_flags.contains(ColumnFlags::UNSIGNED_FLAG) =>
155        {
156            MysqlType::UnsignedShort
157        }
158        ColumnType::MYSQL_TYPE_YEAR | ColumnType::MYSQL_TYPE_SHORT => MysqlType::Short,
159        ColumnType::MYSQL_TYPE_INT24 | ColumnType::MYSQL_TYPE_LONG
160            if column_flags.contains(ColumnFlags::UNSIGNED_FLAG) =>
161        {
162            MysqlType::UnsignedLong
163        }
164        ColumnType::MYSQL_TYPE_INT24 | ColumnType::MYSQL_TYPE_LONG => MysqlType::Long,
165        ColumnType::MYSQL_TYPE_LONGLONG if column_flags.contains(ColumnFlags::UNSIGNED_FLAG) => {
166            MysqlType::UnsignedLongLong
167        }
168        ColumnType::MYSQL_TYPE_LONGLONG => MysqlType::LongLong,
169        ColumnType::MYSQL_TYPE_FLOAT => MysqlType::Float,
170        ColumnType::MYSQL_TYPE_DOUBLE => MysqlType::Double,
171
172        ColumnType::MYSQL_TYPE_TIMESTAMP => MysqlType::Timestamp,
173        ColumnType::MYSQL_TYPE_DATE => MysqlType::Date,
174        ColumnType::MYSQL_TYPE_TIME => MysqlType::Time,
175        ColumnType::MYSQL_TYPE_DATETIME => MysqlType::DateTime,
176        ColumnType::MYSQL_TYPE_BIT => MysqlType::Bit,
177        ColumnType::MYSQL_TYPE_JSON => MysqlType::String,
178
179        ColumnType::MYSQL_TYPE_VAR_STRING
180        | ColumnType::MYSQL_TYPE_STRING
181        | ColumnType::MYSQL_TYPE_TINY_BLOB
182        | ColumnType::MYSQL_TYPE_MEDIUM_BLOB
183        | ColumnType::MYSQL_TYPE_LONG_BLOB
184        | ColumnType::MYSQL_TYPE_BLOB
185            if column_flags.contains(ColumnFlags::ENUM_FLAG) =>
186        {
187            MysqlType::Enum
188        }
189        ColumnType::MYSQL_TYPE_VAR_STRING
190        | ColumnType::MYSQL_TYPE_STRING
191        | ColumnType::MYSQL_TYPE_TINY_BLOB
192        | ColumnType::MYSQL_TYPE_MEDIUM_BLOB
193        | ColumnType::MYSQL_TYPE_LONG_BLOB
194        | ColumnType::MYSQL_TYPE_BLOB
195            if column_flags.contains(ColumnFlags::SET_FLAG) =>
196        {
197            MysqlType::Set
198        }
199
200        ColumnType::MYSQL_TYPE_VAR_STRING
201        | ColumnType::MYSQL_TYPE_STRING
202        | ColumnType::MYSQL_TYPE_TINY_BLOB
203        | ColumnType::MYSQL_TYPE_MEDIUM_BLOB
204        | ColumnType::MYSQL_TYPE_LONG_BLOB
205        | ColumnType::MYSQL_TYPE_BLOB
206            if column_flags.contains(ColumnFlags::BINARY_FLAG) =>
207        {
208            MysqlType::Blob
209        }
210
211        ColumnType::MYSQL_TYPE_VAR_STRING
212        | ColumnType::MYSQL_TYPE_STRING
213        | ColumnType::MYSQL_TYPE_TINY_BLOB
214        | ColumnType::MYSQL_TYPE_MEDIUM_BLOB
215        | ColumnType::MYSQL_TYPE_LONG_BLOB
216        | ColumnType::MYSQL_TYPE_BLOB => MysqlType::String,
217
218        ColumnType::MYSQL_TYPE_NULL
219        | ColumnType::MYSQL_TYPE_NEWDATE
220        | ColumnType::MYSQL_TYPE_VARCHAR
221        | ColumnType::MYSQL_TYPE_TIMESTAMP2
222        | ColumnType::MYSQL_TYPE_DATETIME2
223        | ColumnType::MYSQL_TYPE_TIME2
224        | ColumnType::MYSQL_TYPE_TYPED_ARRAY
225        | ColumnType::MYSQL_TYPE_UNKNOWN
226        | ColumnType::MYSQL_TYPE_ENUM
227        | ColumnType::MYSQL_TYPE_SET
228        | ColumnType::MYSQL_TYPE_VECTOR
229        | ColumnType::MYSQL_TYPE_GEOMETRY => {
230            unimplemented!("Hit an unsupported type: {:?}", column_type)
231        }
232    }
233}