1use byteorder::{NetworkEndian, ReadBytesExt, WriteBytesExt};
2use std::io::Write;
3use std::ops::Bound;
4
5use crate::deserialize::{self, Defaultable, FromSql};
6use crate::expression::bound::Bound as SqlBound;
7use crate::expression::AsExpression;
8use crate::pg::{Pg, PgTypeMetadata, PgValue};
9use crate::query_builder::bind_collector::ByteWrapper;
10use crate::serialize::{self, IsNull, Output, ToSql};
11use crate::sql_types::*;
12
13macro_rules! multirange_has_sql_type {
15 ($ty:ty, $oid:expr, $array_oid:expr) => {
16 #[cfg(feature = "postgres_backend")]
17 impl HasSqlType<$ty> for Pg {
18 fn metadata(_: &mut Self::MetadataLookup) -> PgTypeMetadata {
19 PgTypeMetadata::new($oid, $array_oid)
20 }
21 }
22 };
23}
24multirange_has_sql_type!(Datemultirange, 4535, 6155);
25multirange_has_sql_type!(Int4multirange, 4451, 6150);
26multirange_has_sql_type!(Int8multirange, 4536, 6157);
27multirange_has_sql_type!(Nummultirange, 4532, 6151);
28multirange_has_sql_type!(Tsmultirange, 4533, 6152);
29multirange_has_sql_type!(Tstzmultirange, 4534, 6153);
30
31macro_rules! multirange_as_expression {
32 ($ty:ty, $sql_type:ty) => {
33 #[cfg(feature = "postgres_backend")]
34 #[allow(clippy::extra_unused_lifetimes)]
37 impl<'a, 'b, ST: 'static, T> AsExpression<$sql_type> for $ty {
38 type Expression = SqlBound<$sql_type, Self>;
39 fn as_expression(self) -> Self::Expression {
40 SqlBound::new(self)
41 }
42 }
43 };
44}
45
46macro_rules! multirange_as_expressions {
47 ($ty:ty) => {
48 multirange_as_expression!(&'a [$ty], Multirange<ST>);
49 multirange_as_expression!(&'a [$ty], Nullable<Multirange<ST>>);
50 multirange_as_expression!(&'a &'b [$ty], Multirange<ST>);
51 multirange_as_expression!(&'a &'b [$ty], Nullable<Multirange<ST>>);
52 multirange_as_expression!(Vec<$ty>, Multirange<ST>);
53 multirange_as_expression!(Vec<$ty>, Nullable<Multirange<ST>>);
54 multirange_as_expression!(&'a Vec<$ty>, Multirange<ST>);
55 multirange_as_expression!(&'a Vec<$ty>, Nullable<Multirange<ST>>);
56 multirange_as_expression!(&'a &'b Vec<$ty>, Multirange<ST>);
57 multirange_as_expression!(&'a &'b Vec<$ty>, Nullable<Multirange<ST>>);
58 };
59}
60
61multirange_as_expressions!((Bound<T>, Bound<T>));
62multirange_as_expressions!(std::ops::Range<T>);
63multirange_as_expressions!(std::ops::RangeInclusive<T>);
64multirange_as_expressions!(std::ops::RangeToInclusive<T>);
65multirange_as_expressions!(std::ops::RangeFrom<T>);
66multirange_as_expressions!(std::ops::RangeTo<T>);
67
68#[cfg(feature = "postgres_backend")]
69impl<T, ST> FromSql<Multirange<ST>, Pg> for Vec<(Bound<T>, Bound<T>)>
70where
71 T: FromSql<ST, Pg> + Defaultable,
72{
73 fn from_sql(value: PgValue<'_>) -> deserialize::Result<Self> {
74 let mut bytes = value.as_bytes();
75 let len = bytes.read_u32::<NetworkEndian>()?;
76
77 (0..len)
78 .map(|_| {
79 let range_size: usize = bytes.read_i32::<NetworkEndian>()?.try_into()?;
80 let (range_bytes, new_bytes) = bytes.split_at(range_size);
81 bytes = new_bytes;
82 FromSql::from_sql(PgValue::new_internal(range_bytes, &value))
83 })
84 .collect()
85 }
86}
87
88fn to_sql<'c, ST, T, I>(iter: I, out: &mut Output<'_, '_, Pg>) -> serialize::Result
89where
90 ST: 'static,
91 T: ToSql<ST, Pg> + 'c,
92 I: Iterator<Item = (Bound<&'c T>, Bound<&'c T>)> + ExactSizeIterator,
93{
94 out.write_u32::<NetworkEndian>(iter.len().try_into()?)?;
95
96 let mut buffer = Vec::new();
97 for value in iter {
98 {
99 let mut inner_buffer = Output::new(ByteWrapper(&mut buffer), out.metadata_lookup());
100 ToSql::<Range<ST>, Pg>::to_sql(&value, &mut inner_buffer)?;
101 }
102 let buffer_len: i32 = buffer.len().try_into()?;
103 out.write_i32::<NetworkEndian>(buffer_len)?;
104 out.write_all(&buffer)?;
105 buffer.clear();
106 }
107
108 Ok(IsNull::No)
109}
110
111#[cfg(feature = "postgres_backend")]
112impl<T, ST> ToSql<Multirange<ST>, Pg> for [(Bound<T>, Bound<T>)]
113where
114 T: ToSql<ST, Pg>,
115{
116 fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
117 to_sql(self.iter().map(|r| (r.0.as_ref(), r.1.as_ref())), out)
118 }
119}
120
121#[cfg(feature = "postgres_backend")]
122impl<T, ST> ToSql<Multirange<ST>, Pg> for Vec<(Bound<T>, Bound<T>)>
123where
124 T: ToSql<ST, Pg>,
125 [(Bound<T>, Bound<T>)]: ToSql<Multirange<ST>, Pg>,
126{
127 fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
128 ToSql::<Multirange<ST>, Pg>::to_sql(self.as_slice(), out)
129 }
130}
131
132use std::ops::RangeBounds;
133macro_rules! multirange_std_to_sql {
134 ($ty:ty) => {
135 #[cfg(feature = "postgres_backend")]
136 impl<ST, T> ToSql<Multirange<ST>, Pg> for [$ty]
137 where
138 ST: 'static,
139 T: ToSql<ST, Pg>,
140 {
141 fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
142 to_sql(
143 self.into_iter().map(|r| (r.start_bound(), r.end_bound())),
144 out,
145 )
146 }
147 }
148
149 #[cfg(feature = "postgres_backend")]
150 impl<T, ST> ToSql<Multirange<ST>, Pg> for Vec<$ty>
151 where
152 T: ToSql<ST, Pg>,
153 [$ty]: ToSql<Multirange<ST>, Pg>,
154 {
155 fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
156 ToSql::<Multirange<ST>, Pg>::to_sql(self.as_slice(), out)
157 }
158 }
159 };
160}
161
162multirange_std_to_sql!(std::ops::Range<T>);
163multirange_std_to_sql!(std::ops::RangeInclusive<T>);
164multirange_std_to_sql!(std::ops::RangeFrom<T>);
165multirange_std_to_sql!(std::ops::RangeTo<T>);
166multirange_std_to_sql!(std::ops::RangeToInclusive<T>);
167
168macro_rules! multirange_to_sql_nullable {
169 ($ty:ty) => {
170 impl<T, ST> ToSql<Nullable<Multirange<ST>>, Pg> for [$ty]
171 where
172 ST: 'static,
173 [$ty]: ToSql<ST, Pg>,
174 T: ToSql<ST, Pg>,
175 {
176 fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
177 ToSql::<Multirange<ST>, Pg>::to_sql(self, out)
178 }
179 }
180
181 impl<T, ST> ToSql<Nullable<Multirange<ST>>, Pg> for Vec<$ty>
182 where
183 ST: 'static,
184 Vec<$ty>: ToSql<ST, Pg>,
185 T: ToSql<ST, Pg>,
186 {
187 fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
188 ToSql::<Multirange<ST>, Pg>::to_sql(self, out)
189 }
190 }
191 };
192}
193
194multirange_to_sql_nullable!((Bound<T>, Bound<T>));
195multirange_to_sql_nullable!(std::ops::Range<T>);
196multirange_to_sql_nullable!(std::ops::RangeInclusive<T>);
197multirange_to_sql_nullable!(std::ops::RangeFrom<T>);
198multirange_to_sql_nullable!(std::ops::RangeTo<T>);
199multirange_to_sql_nullable!(std::ops::RangeToInclusive<T>);