rbdc_pg/types/
int.rs

1use crate::arguments::PgArgumentBuffer;
2use crate::type_info::PgTypeInfo;
3use crate::types::decode::Decode;
4use crate::types::encode::{Encode, IsNull};
5use crate::types::TypeInfo;
6use crate::value::{PgValueFormat, PgValueRef};
7use byteorder::{BigEndian, ByteOrder};
8use rbdc::Error;
9
10impl Decode for u64 {
11    fn decode(value: PgValueRef) -> Result<Self, Error> {
12        Ok(match value.format() {
13            PgValueFormat::Binary => BigEndian::read_u64(value.as_bytes()?),
14            PgValueFormat::Text => value.as_str()?.parse()?,
15        })
16    }
17}
18
19impl Decode for u32 {
20    fn decode(value: PgValueRef) -> Result<Self, Error> {
21        Ok(match value.format() {
22            PgValueFormat::Binary => {
23                let bytes = value.as_bytes()?;
24                if bytes.len() == 8 {
25                    BigEndian::read_u64(bytes) as u32
26                } else if bytes.len() == 4 {
27                    BigEndian::read_u32(bytes)
28                } else {
29                    return Err(Error::from("error u32 bytes len"));
30                }
31            }
32            PgValueFormat::Text => value.as_str()?.parse()?,
33        })
34    }
35}
36
37impl Decode for u16 {
38    fn decode(value: PgValueRef) -> Result<Self, Error> {
39        Ok(match value.format() {
40            PgValueFormat::Binary => {
41                let bytes = value.as_bytes()?;
42                if bytes.len() == 8 {
43                    BigEndian::read_u64(bytes) as u16
44                } else if bytes.len() == 4 {
45                    BigEndian::read_u32(bytes) as u16
46                } else if bytes.len() == 2 {
47                    BigEndian::read_u16(bytes)
48                } else {
49                    return Err(Error::from("error u16 bytes len"));
50                }
51            }
52            PgValueFormat::Text => value.as_str()?.parse()?,
53        })
54    }
55}
56
57impl Decode for u8 {
58    fn decode(value: PgValueRef) -> Result<Self, Error> {
59        // note: in the TEXT encoding, a value of "0" here is encoded as an empty string
60        Ok(value.as_bytes()?.get(0).copied().unwrap_or_default() as u8)
61    }
62}
63
64impl Decode for i64 {
65    fn decode(value: PgValueRef) -> Result<Self, Error> {
66        Ok(match value.format() {
67            PgValueFormat::Binary => BigEndian::read_i64(value.as_bytes()?),
68            PgValueFormat::Text => value.as_str()?.parse()?,
69        })
70    }
71}
72
73impl Decode for i32 {
74    fn decode(value: PgValueRef) -> Result<Self, Error> {
75        Ok(match value.format() {
76            PgValueFormat::Binary => {
77                let bytes = value.as_bytes()?;
78                if bytes.len() == 8 {
79                    BigEndian::read_i64(bytes) as i32
80                } else if bytes.len() == 4 {
81                    BigEndian::read_i32(bytes)
82                } else {
83                    return Err(Error::from("error i32 bytes len"));
84                }
85            }
86            PgValueFormat::Text => value.as_str()?.parse()?,
87        })
88    }
89}
90
91impl Decode for i16 {
92    fn decode(value: PgValueRef) -> Result<Self, Error> {
93        Ok(match value.format() {
94            PgValueFormat::Binary => {
95                let bytes = value.as_bytes()?;
96                if bytes.len() == 8 {
97                    BigEndian::read_i64(bytes) as i16
98                } else if bytes.len() == 4 {
99                    BigEndian::read_i32(bytes) as i16
100                } else if bytes.len() == 2 {
101                    BigEndian::read_i16(bytes)
102                } else {
103                    return Err(Error::from("error i16 bytes len"));
104                }
105            }
106            PgValueFormat::Text => value.as_str()?.parse()?,
107        })
108    }
109}
110
111impl Decode for i8 {
112    fn decode(value: PgValueRef) -> Result<Self, Error> {
113        // note: in the TEXT encoding, a value of "0" here is encoded as an empty string
114        Ok(value.as_bytes()?.get(0).copied().unwrap_or_default() as i8)
115    }
116}
117
118///encode
119
120impl Encode for u64 {
121    fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Error> {
122        buf.extend(&self.to_be_bytes());
123        Ok(IsNull::No)
124    }
125}
126
127impl Encode for u32 {
128    fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Error> {
129        buf.extend(&self.to_be_bytes());
130
131        Ok(IsNull::No)
132    }
133}
134
135impl Encode for u16 {
136    fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Error> {
137        buf.extend(&self.to_be_bytes());
138
139        Ok(IsNull::No)
140    }
141}
142
143impl Encode for u8 {
144    fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Error> {
145        buf.extend(&self.to_be_bytes());
146
147        Ok(IsNull::No)
148    }
149}
150
151impl Encode for i64 {
152    fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Error> {
153        buf.extend(&self.to_be_bytes());
154
155        Ok(IsNull::No)
156    }
157}
158
159impl Encode for i32 {
160    fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Error> {
161        buf.extend(&self.to_be_bytes());
162
163        Ok(IsNull::No)
164    }
165}
166
167impl Encode for i16 {
168    fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Error> {
169        buf.extend(&self.to_be_bytes());
170
171        Ok(IsNull::No)
172    }
173}
174
175impl Encode for i8 {
176    fn encode(self, buf: &mut PgArgumentBuffer) -> Result<IsNull, Error> {
177        buf.extend(&self.to_be_bytes());
178
179        Ok(IsNull::No)
180    }
181}
182
183///TypeInfo
184
185impl TypeInfo for i8 {
186    fn type_info(&self) -> PgTypeInfo {
187        PgTypeInfo::BYTEA
188    }
189}
rbdc_pg/types/int.rs

rbdc_pg/types/
int.rs
