Skip to main content

sqlx_sqlserver/
any.rs

1//! Runtime `Any` driver registration for SQL Server.
2//!
3//! The driver can be installed with SQLx `Any`. The current SQL Server port supports SQL batch
4//! execution and the same stable scalar RPC argument types as the native connection.
5
6use 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
30/// Installable SQL Server driver for SQLx `Any` connections.
31pub 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(), &parameters).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}