Run rustfmt

sqlx-core/src/mysql/types/bytes.rs

@@ -2,7 +2,7 @@ use byteorder::LittleEndian;
 
 use crate::decode::Decode;
 use crate::encode::Encode;
-use crate::mysql::io::{BufMutExt};
+use crate::mysql::io::BufMutExt;
 use crate::mysql::protocol::TypeId;
 use crate::mysql::types::MySqlTypeInfo;
 use crate::mysql::{MySql, MySqlValue};

sqlx-core/src/mysql/types/str.rs

@@ -4,7 +4,7 @@ use byteorder::LittleEndian;
 
 use crate::decode::Decode;
 use crate::encode::Encode;
-use crate::mysql::io::{BufMutExt};
+use crate::mysql::io::BufMutExt;
 use crate::mysql::protocol::TypeId;
 use crate::mysql::types::MySqlTypeInfo;
 use crate::mysql::{MySql, MySqlValue};

sqlx-core/src/runtime.rs

@@ -6,8 +6,8 @@ pub use async_std::{
     io::{Read as AsyncRead, Write as AsyncWrite},
     net::TcpStream,
     task::sleep,
-    task::{spawn, spawn_blocking},
     task::yield_now,
+    task::{spawn, spawn_blocking},
 };
 
 #[cfg(feature = "runtime-tokio")]
@@ -15,8 +15,8 @@ pub use tokio::{
     fs,
     io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},
     net::TcpStream,
-    task::{spawn, spawn_blocking},
     task::yield_now,
+    task::{spawn, spawn_blocking},
     time::delay_for as sleep,
     time::timeout,
 };

sqlx-core/src/sqlite/arguments.rs

@@ -1,8 +1,8 @@
 use crate::arguments::Arguments;
 use crate::encode::Encode;
+use crate::sqlite::value::SqliteArgumentValue;
 use crate::sqlite::Sqlite;
 use crate::types::Type;
-use crate::sqlite::value::SqliteArgumentValue;
 
 #[derive(Default)]
 pub struct SqliteArguments {

sqlx-core/src/sqlite/connection.rs

@@ -1,4 +1,4 @@
-use core::ptr::{NonNull, null, null_mut};
+use core::ptr::{null, null_mut, NonNull};
 
 use std::convert::TryInto;
 use std::ffi::CString;
@@ -10,11 +10,11 @@ use libsqlite3_sys::{
     SQLITE_OPEN_READWRITE, SQLITE_OPEN_SHAREDCACHE,
 };
 
-use crate::runtime::spawn_blocking;
 use crate::connection::{Connect, Connection};
+use crate::runtime::spawn_blocking;
+use crate::sqlite::SqliteError;
 use crate::url::Url;
 use futures_util::future;
-use crate::sqlite::SqliteError;
 
 #[derive(Debug)]
 pub struct SqliteConnection {
@@ -46,16 +46,12 @@ fn establish(url: crate::Result<Url>) -> crate::Result<SqliteConnection> {
 
     // [SQLITE_OPEN_NOMUTEX] will instruct [sqlite3_open_v2] to return an error if it
     // cannot satisfy our wish for a thread-safe, lock-free connection object
-    let flags = SQLITE_OPEN_READWRITE
-        | SQLITE_OPEN_CREATE
-        | SQLITE_OPEN_NOMUTEX
-        | SQLITE_OPEN_SHAREDCACHE;
+    let flags =
+        SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_SHAREDCACHE;
 
     // <https://www.sqlite.org/c3ref/open.html>
     #[allow(unsafe_code)]
-    let status = unsafe {
-        sqlite3_open_v2(filename.as_ptr(), &mut handle, flags, null())
-    };
+    let status = unsafe { sqlite3_open_v2(filename.as_ptr(), &mut handle, flags, null()) };
 
     if status != SQLITE_OK {
         return Err(SqliteError::new(status).into());

sqlx-core/src/sqlite/database.rs

@@ -1,5 +1,5 @@
 use crate::database::{Database, HasCursor, HasRawValue, HasRow};
-use crate::sqlite::value::{SqliteResultValue, SqliteArgumentValue};
+use crate::sqlite::value::{SqliteArgumentValue, SqliteResultValue};
 
 /// **Sqlite** database driver.
 pub struct Sqlite;

sqlx-core/src/sqlite/error.rs

@@ -1,7 +1,7 @@
 use crate::error::DatabaseError;
 use libc::c_int;
-use std::ffi::CStr;
 use libsqlite3_sys::{sqlite3, sqlite3_errstr};
+use std::ffi::CStr;
 
 pub struct SqliteError {
     #[allow(dead_code)]
@@ -12,11 +12,12 @@ pub struct SqliteError {
 impl SqliteError {
     pub(crate) fn new(code: c_int) -> Self {
         #[allow(unsafe_code)]
-        let message = unsafe {
-            CStr::from_ptr(sqlite3_errstr(code))
-        };
+        let message = unsafe { CStr::from_ptr(sqlite3_errstr(code)) };
 
-        Self { code, message: message.to_string_lossy().into_owned() }
+        Self {
+            code,
+            message: message.to_string_lossy().into_owned(),
+        }
     }
 }
 

sqlx-core/src/sqlite/executor.rs

@@ -41,10 +41,10 @@ impl Executor for super::SqliteConnection {
     }
 }
 
-impl<'c> RefExecutor<'c> for &'c mut super::SqliteConnection {
+impl<'e> RefExecutor<'e> for &'e mut super::SqliteConnection {
     type Database = Sqlite;
 
-    fn fetch_by_ref<'q, E>(self, query: E) -> SqliteCursor<'c, 'q>
+    fn fetch_by_ref<'q, E>(self, query: E) -> SqliteCursor<'e, 'q>
     where
         E: Execute<'q, Self::Database>,
     {

sqlx-core/src/sqlite/mod.rs

@@ -3,10 +3,10 @@ mod connection;
 mod cursor;
 mod database;
 mod error;
-mod value;
 mod executor;
 mod row;
 mod types;
+mod value;
 
 pub use arguments::SqliteArguments;
 pub use connection::SqliteConnection;

sqlx-core/src/sqlite/row.rs

@@ -6,8 +6,8 @@ use std::sync::Arc;
 
 use crate::error::UnexpectedNullError;
 use crate::row::{ColumnIndex, Row};
-use crate::sqlite::Sqlite;
 use crate::sqlite::value::SqliteResultValue;
+use crate::sqlite::Sqlite;
 
 pub struct SqliteRow<'c> {
     c: std::marker::PhantomData<&'c ()>,

sqlx-core/src/sqlite/types/int.rs

@@ -1,8 +1,8 @@
-use crate::types::Type;
-use crate::sqlite::{Sqlite, SqliteTypeInfo};
+use crate::decode::Decode;
 use crate::encode::Encode;
 use crate::sqlite::value::{SqliteArgumentValue, SqliteResultValue};
-use crate::decode::Decode;
+use crate::sqlite::{Sqlite, SqliteTypeInfo};
+use crate::types::Type;
 
 impl Type<Sqlite> for i32 {
     fn type_info() -> SqliteTypeInfo {

sqlx-core/src/transaction.rs

@@ -127,14 +127,14 @@ where
     }
 }
 
-impl<'c, DB, T> RefExecutor<'c> for &'c mut Transaction<T>
+impl<'e, DB, T> RefExecutor<'e> for &'e mut Transaction<T>
 where
     DB: Database,
     T: Connection<Database = DB>,
 {
     type Database = DB;
 
-    fn fetch_by_ref<'q, E>(self, query: E) -> <Self::Database as HasCursor<'c, 'q>>::Cursor
+    fn fetch_by_ref<'q, E>(self, query: E) -> <Self::Database as HasCursor<'e, 'q>>::Cursor
     where
         E: Execute<'q, Self::Database>,
     {

src/lib.rs

@@ -34,7 +34,7 @@ pub use sqlx_core::postgres::{self, PgConnection, PgPool, Postgres};
 
 #[cfg(feature = "sqlite")]
 #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
-pub use sqlx_core::sqlite::{self, SqliteConnection, SqlitePool, Sqlite};
+pub use sqlx_core::sqlite::{self, Sqlite, SqliteConnection, SqlitePool};
 
 #[cfg(feature = "macros")]
 #[doc(hidden)]

tests/derives.rs

@@ -6,8 +6,7 @@ struct Foo(i32);
 
 #[test]
 #[cfg(feature = "postgres")]
-fn encode_with_postgres()
-{
+fn encode_with_postgres() {
     use sqlx_core::postgres::Postgres;
 
     let example = Foo(0x1122_3344);
@@ -23,8 +22,7 @@ fn encode_with_postgres()
 
 #[test]
 #[cfg(feature = "mysql")]
-fn encode_with_mysql()
-{
+fn encode_with_mysql() {
     use sqlx_core::mysql::MySql;
 
     let example = Foo(0x1122_3344);

tests/sqlite.rs

@@ -1,5 +1,7 @@
 use futures::TryStreamExt;
-use sqlx::{sqlite::SqliteQueryAs, Connection, Executor, Sqlite, SqlitePool, SqliteConnection, Connect};
+use sqlx::{
+    sqlite::SqliteQueryAs, Connect, Connection, Executor, Sqlite, SqliteConnection, SqlitePool,
+};
 use sqlx_test::new;
 use std::time::Duration;
 
@@ -14,7 +16,10 @@ async fn it_connects() -> anyhow::Result<()> {
 async fn it_fails_to_connect() -> anyhow::Result<()> {
     // empty connection string
     assert!(SqliteConnection::connect("").await.is_err());
-    assert!(dbg!(SqliteConnection::connect("sqlite:///please_do_not_run_sqlx_tests_as_root").await).is_err());
+    assert!(dbg!(
+        SqliteConnection::connect("sqlite:///please_do_not_run_sqlx_tests_as_root").await
+    )
+    .is_err());
 
     Ok(())
 }