1use crate::{
7 Mssql, MssqlArguments, MssqlColumn, MssqlConnectOptions, MssqlConnection, MssqlQueryResult,
8 MssqlTransactionManager, MssqlType, MssqlTypeInfo,
9};
10use futures_core::future::BoxFuture;
11use futures_core::stream::BoxStream;
12use futures_util::{FutureExt, StreamExt, TryStreamExt};
13use sqlx_core::any::driver::AnyDriver;
14use sqlx_core::any::{
15 AnyArguments, AnyColumn, AnyConnectOptions, AnyConnectionBackend, AnyQueryResult, AnyRow,
16 AnyStatement, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind,
17};
18use sqlx_core::arguments::Arguments;
19use sqlx_core::column::Column;
20use sqlx_core::connection::{ConnectOptions, Connection};
21use sqlx_core::database::Database;
22use sqlx_core::ext::ustr::UStr;
23use sqlx_core::row::Row;
24use sqlx_core::sql_str::SqlStr;
25use sqlx_core::statement::Statement;
26use sqlx_core::transaction::TransactionManager;
27use sqlx_core::{Either, Error, HashMap};
28use std::sync::Arc;
29
30pub const DRIVER: AnyDriver = AnyDriver::with_migrate::<Mssql>();
32
33impl AnyConnectionBackend for MssqlConnection {
34 fn name(&self) -> &str {
35 <Mssql as Database>::NAME
36 }
37
38 fn close(self: Box<Self>) -> BoxFuture<'static, sqlx_core::Result<()>> {
39 Connection::close(*self).boxed()
40 }
41
42 fn close_hard(self: Box<Self>) -> BoxFuture<'static, sqlx_core::Result<()>> {
43 Connection::close_hard(*self).boxed()
44 }
45
46 fn ping(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
47 Connection::ping(self).boxed()
48 }
49
50 fn begin(&mut self, statement: Option<SqlStr>) -> BoxFuture<'_, sqlx_core::Result<()>> {
51 MssqlTransactionManager::begin(self, statement).boxed()
52 }
53
54 fn commit(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
55 MssqlTransactionManager::commit(self).boxed()
56 }
57
58 fn rollback(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
59 MssqlTransactionManager::rollback(self).boxed()
60 }
61
62 fn start_rollback(&mut self) {
63 MssqlTransactionManager::start_rollback(self);
64 }
65
66 fn get_transaction_depth(&self) -> usize {
67 MssqlTransactionManager::get_transaction_depth(self)
68 }
69
70 fn shrink_buffers(&mut self) {
71 Connection::shrink_buffers(self);
72 }
73
74 fn flush(&mut self) -> BoxFuture<'_, sqlx_core::Result<()>> {
75 Connection::flush(self).boxed()
76 }
77
78 fn should_flush(&self) -> bool {
79 Connection::should_flush(self)
80 }
81
82 #[cfg(feature = "migrate")]
83 fn as_migrate(
84 &mut self,
85 ) -> sqlx_core::Result<&mut (dyn sqlx_core::migrate::Migrate + Send + 'static)> {
86 Ok(self)
87 }
88
89 fn fetch_many(
90 &mut self,
91 query: SqlStr,
92 _persistent: bool,
93 arguments: Option<AnyArguments>,
94 ) -> BoxStream<'_, sqlx_core::Result<Either<AnyQueryResult, AnyRow>>> {
95 let native_arguments = arguments
96 .map(convert_any_arguments)
97 .transpose()
98 .map_err(Error::Encode);
99
100 self.fetch_many_sql(query, native_arguments)
101 .map(|item| match item? {
102 Either::Left(result) => Ok(Either::Left(map_result(result))),
103 Either::Right(row) => {
104 let column_names = column_names(row.columns());
105 AnyRow::map_from(&row, column_names).map(Either::Right)
106 }
107 })
108 .boxed()
109 }
110
111 fn fetch_optional(
112 &mut self,
113 query: SqlStr,
114 _persistent: bool,
115 arguments: Option<AnyArguments>,
116 ) -> BoxFuture<'_, sqlx_core::Result<Option<AnyRow>>> {
117 Box::pin(async move {
118 let native_arguments = arguments
119 .map(convert_any_arguments)
120 .transpose()
121 .map_err(Error::Encode)?;
122 let mut stream = self.fetch_many_sql(query, Ok(native_arguments));
123
124 while let Some(item) = stream.try_next().await? {
125 if let Either::Right(row) = item {
126 let column_names = column_names(row.columns());
127 return AnyRow::map_from(&row, column_names).map(Some);
128 }
129 }
130
131 Ok(None)
132 })
133 }
134
135 fn prepare_with<'c, 'q: 'c>(
136 &'c mut self,
137 sql: SqlStr,
138 parameters: &[AnyTypeInfo],
139 ) -> BoxFuture<'c, sqlx_core::Result<AnyStatement>> {
140 let parameters = parameters
141 .iter()
142 .map(mssql_type_from_any)
143 .collect::<Result<Vec<_>, _>>();
144
145 Box::pin(async move {
146 let parameters = parameters?;
147 let statement = self.run_prepare(sql.as_str(), ¶meters).await?;
148 let statement = crate::MssqlStatement::with_parameters(
149 sql,
150 statement.columns,
151 if parameters.is_empty() {
152 None
153 } else {
154 Some(Either::Left(parameters))
155 },
156 );
157 let column_names = column_names(statement.columns());
158 AnyStatement::try_from_statement(statement, column_names)
159 })
160 }
161}
162
163fn mssql_type_from_any(type_info: &AnyTypeInfo) -> Result<MssqlTypeInfo, Error> {
164 Ok(match type_info.kind() {
165 AnyTypeInfoKind::Bool => MssqlTypeInfo::BIT,
166 AnyTypeInfoKind::SmallInt => MssqlTypeInfo::SMALLINT,
167 AnyTypeInfoKind::Integer | AnyTypeInfoKind::Null => MssqlTypeInfo::INT,
168 AnyTypeInfoKind::BigInt => MssqlTypeInfo::BIGINT,
169 AnyTypeInfoKind::Real => MssqlTypeInfo::REAL,
170 AnyTypeInfoKind::Double => MssqlTypeInfo::FLOAT,
171 AnyTypeInfoKind::Text => MssqlTypeInfo::NVARCHAR,
172 AnyTypeInfoKind::Blob => MssqlTypeInfo::VARBINARY,
173 })
174}
175
176fn convert_any_arguments(
177 arguments: AnyArguments,
178) -> Result<MssqlArguments, sqlx_core::error::BoxDynError> {
179 let mut out = MssqlArguments::default();
180
181 for argument in arguments.values.0 {
182 match argument {
183 AnyValueKind::Null(AnyTypeInfoKind::Null) => out.add(Option::<i32>::None),
184 AnyValueKind::Null(AnyTypeInfoKind::Bool) => out.add(Option::<bool>::None),
185 AnyValueKind::Null(AnyTypeInfoKind::SmallInt) => out.add(Option::<i16>::None),
186 AnyValueKind::Null(AnyTypeInfoKind::Integer) => out.add(Option::<i32>::None),
187 AnyValueKind::Null(AnyTypeInfoKind::BigInt) => out.add(Option::<i64>::None),
188 AnyValueKind::Null(AnyTypeInfoKind::Real) => out.add(Option::<f32>::None),
189 AnyValueKind::Null(AnyTypeInfoKind::Double) => out.add(Option::<f64>::None),
190 AnyValueKind::Null(AnyTypeInfoKind::Text) => out.add(Option::<String>::None),
191 AnyValueKind::Null(AnyTypeInfoKind::Blob) => out.add(Option::<Vec<u8>>::None),
192 AnyValueKind::Bool(value) => out.add(value),
193 AnyValueKind::SmallInt(value) => out.add(value),
194 AnyValueKind::Integer(value) => out.add(value),
195 AnyValueKind::BigInt(value) => out.add(value),
196 AnyValueKind::Real(value) => out.add(value),
197 AnyValueKind::Double(value) => out.add(value),
198 AnyValueKind::Text(value) => out.add(value.as_str()),
199 AnyValueKind::TextSlice(value) => out.add(value.as_ref()),
200 AnyValueKind::Blob(value) => out.add(value.as_slice()),
201 other => {
202 return Err(format!(
203 "SQL Server Any driver does not support argument value {other:?}"
204 )
205 .into());
206 }
207 }?;
208 }
209
210 Ok(out)
211}
212
213fn map_result(result: MssqlQueryResult) -> AnyQueryResult {
214 AnyQueryResult {
215 rows_affected: result.rows_affected(),
216 last_insert_id: None,
217 }
218}
219
220fn column_names(columns: &[MssqlColumn]) -> Arc<HashMap<UStr, usize>> {
221 Arc::new(
222 columns
223 .iter()
224 .map(|column| (UStr::new(column.name()), column.ordinal()))
225 .collect(),
226 )
227}
228
229impl<'a> TryFrom<&'a AnyConnectOptions> for MssqlConnectOptions {
230 type Error = Error;
231
232 fn try_from(options: &'a AnyConnectOptions) -> Result<Self, Self::Error> {
233 MssqlConnectOptions::from_url(&options.database_url)
234 }
235}
236
237impl<'a> TryFrom<&'a MssqlTypeInfo> for AnyTypeInfo {
238 type Error = Error;
239
240 fn try_from(type_info: &'a MssqlTypeInfo) -> Result<Self, Self::Error> {
241 let kind = match type_info.kind() {
242 MssqlType::Null => AnyTypeInfoKind::Null,
243 MssqlType::Bit => AnyTypeInfoKind::Bool,
244 MssqlType::SmallInt => AnyTypeInfoKind::SmallInt,
245 MssqlType::Int => AnyTypeInfoKind::Integer,
246 MssqlType::BigInt => AnyTypeInfoKind::BigInt,
247 MssqlType::Real => AnyTypeInfoKind::Real,
248 MssqlType::Float => AnyTypeInfoKind::Double,
249 MssqlType::NVarChar | MssqlType::VarChar => AnyTypeInfoKind::Text,
250 MssqlType::VarBinary => AnyTypeInfoKind::Blob,
251 MssqlType::TinyInt
252 | MssqlType::Decimal
253 | MssqlType::Money
254 | MssqlType::Date
255 | MssqlType::Time
256 | MssqlType::DateTime
257 | MssqlType::DateTime2
258 | MssqlType::DateTimeOffset
259 | MssqlType::UniqueIdentifier
260 | MssqlType::Other(_) => {
261 return Err(Error::AnyDriverError(
262 format!("Any driver does not support the SQL Server type {type_info:?}").into(),
263 ));
264 }
265 };
266
267 Ok(AnyTypeInfo { kind })
268 }
269}
270
271impl<'a> TryFrom<&'a MssqlColumn> for AnyColumn {
272 type Error = Error;
273
274 fn try_from(column: &'a MssqlColumn) -> Result<Self, Self::Error> {
275 let type_info =
276 AnyTypeInfo::try_from(column.type_info()).map_err(|error| Error::ColumnDecode {
277 index: column.name().to_owned(),
278 source: error.into(),
279 })?;
280
281 Ok(Self {
282 ordinal: column.ordinal(),
283 name: UStr::new(column.name()),
284 type_info,
285 })
286 }
287}
288
289#[cfg(test)]
290mod tests {
291 use super::*;
292
293 #[test]
294 fn maps_stable_sql_server_types_to_any_types() {
295 assert_eq!(
296 AnyTypeInfo::try_from(&MssqlTypeInfo::BIT).unwrap().kind(),
297 AnyTypeInfoKind::Bool
298 );
299 assert_eq!(
300 AnyTypeInfo::try_from(&MssqlTypeInfo::INT).unwrap().kind(),
301 AnyTypeInfoKind::Integer
302 );
303 assert_eq!(
304 AnyTypeInfo::try_from(&MssqlTypeInfo::NVARCHAR)
305 .unwrap()
306 .kind(),
307 AnyTypeInfoKind::Text
308 );
309 assert_eq!(
310 AnyTypeInfo::try_from(&MssqlTypeInfo::VARCHAR)
311 .unwrap()
312 .kind(),
313 AnyTypeInfoKind::Text
314 );
315 assert_eq!(
316 AnyTypeInfo::try_from(&MssqlTypeInfo::VARBINARY)
317 .unwrap()
318 .kind(),
319 AnyTypeInfoKind::Blob
320 );
321 }
322
323 #[test]
324 fn rejects_unstable_sql_server_types_for_any_mapping() {
325 assert!(matches!(
326 AnyTypeInfo::try_from(&MssqlTypeInfo::TINYINT),
327 Err(Error::AnyDriverError(_))
328 ));
329 }
330}