feat(core): impl Query, QueryAs, Executor for the blocking runtime

sqlx/src/blocking.rs

@@ -2,6 +2,8 @@
 //! for **blocking** operations.
 //!
 
+mod query;
+mod query_as;
 mod runtime;
 mod stream;
 
@@ -10,4 +12,6 @@ mod stream;
 // for [DbConnection<Blocking>] **and** [DbConnection<Rt> where Rt: Async]
 
 pub use runtime::Blocking;
-pub use sqlx_core::blocking::{Acquire, Close, Connect, ConnectOptions, Connection, Runtime};
+pub use sqlx_core::blocking::{
+    Acquire, Close, Connect, ConnectOptions, Connection, Executor, Runtime,
+};

sqlx/src/blocking/query.rs

@@ -0,0 +1,32 @@
+use crate::blocking::Executor;
+use crate::{Blocking, Database, Query};
+
+impl<'q, 'a, Db: Database> Query<'q, 'a, Db, Blocking> {
+    pub fn execute<X>(&self, mut executor: X) -> crate::Result<Db::QueryResult>
+    where
+        X: Executor<Blocking, Database = Db>,
+    {
+        Executor::execute(&mut executor, self)
+    }
+
+    pub fn fetch_optional<X>(&self, mut executor: X) -> crate::Result<Option<Db::Row>>
+    where
+        X: Executor<Blocking, Database = Db>,
+    {
+        Executor::fetch_optional(&mut executor, self)
+    }
+
+    pub fn fetch_one<X>(&self, mut executor: X) -> crate::Result<Db::Row>
+    where
+        X: Executor<Blocking, Database = Db>,
+    {
+        Executor::fetch_one(&mut executor, self)
+    }
+
+    pub fn fetch_all<X>(&self, mut executor: X) -> crate::Result<Vec<Db::Row>>
+    where
+        X: Executor<Blocking, Database = Db>,
+    {
+        Executor::fetch_all(&mut executor, self)
+    }
+}

sqlx/src/blocking/query_as.rs

@@ -0,0 +1,29 @@
+use crate::blocking::Executor;
+use crate::{Blocking, Database, FromRow, QueryAs};
+
+impl<'q, 'a, O, Db> QueryAs<'q, 'a, O, Db, Blocking>
+where
+    Db: Database,
+    O: Send + Sync + FromRow<Db::Row>,
+{
+    pub fn fetch_optional<X>(&self, mut executor: X) -> crate::Result<Option<O>>
+    where
+        X: Executor<Blocking, Database = Db>,
+    {
+        Executor::fetch_optional(&mut executor, &self.inner)?.as_ref().map(O::from_row).transpose()
+    }
+
+    pub fn fetch_one<X>(&self, mut executor: X) -> crate::Result<O>
+    where
+        X: Executor<Blocking, Database = Db>,
+    {
+        O::from_row(&Executor::fetch_one(&mut executor, &self.inner)?)
+    }
+
+    pub fn fetch_all<X>(&self, mut executor: X) -> crate::Result<Vec<O>>
+    where
+        X: Executor<Blocking, Database = Db>,
+    {
+        Executor::fetch_all(&mut executor, &self.inner)?.iter().map(O::from_row).collect()
+    }
+}

sqlx/src/lib.rs

@@ -70,6 +70,6 @@ pub use sqlx_core::AsyncStd;
 #[cfg(feature = "tokio")]
 pub use sqlx_core::Tokio;
 pub use sqlx_core::{
-    Acquire, Arguments, Close, Connect, ConnectOptions, Connection, Database, Error, Executor,
-    Result, Row, Runtime,
+    Acquire, Arguments, Close, Connect, ConnectOptions, Connection, Database, Decode, Encode,
+    Error, Execute, Executor, FromRow, Result, Row, Runtime, Type,
 };

sqlx/src/mysql/blocking/connection.rs

@@ -1,7 +1,7 @@
-use crate::blocking::{Close, Connect, Connection, Runtime};
+use crate::blocking::{Close, Connect, Connection, Executor, Runtime};
 use crate::mysql::connection::MySqlConnection;
-use crate::mysql::MySqlConnectOptions;
-use crate::{Blocking, Result};
+use crate::mysql::{MySql, MySqlConnectOptions, MySqlQueryResult, MySqlRow};
+use crate::{Blocking, Execute, Result};
 
 impl MySqlConnection<Blocking> {
     /// Open a new database connection.
@@ -69,3 +69,38 @@ impl<Rt: Runtime> Connection<Rt> for MySqlConnection<Rt> {
         self.0.ping()
     }
 }
+
+impl<Rt: Runtime> Executor<Rt> for MySqlConnection<Rt> {
+    #[inline]
+    fn execute<'x, 'e, 'q, 'a, E>(&'e mut self, query: E) -> Result<MySqlQueryResult>
+    where
+        E: 'x + Execute<'q, 'a, MySql>,
+        'e: 'x,
+        'q: 'x,
+        'a: 'x,
+    {
+        self.0.execute(query)
+    }
+
+    #[inline]
+    fn fetch_all<'x, 'e, 'q, 'a, E>(&'e mut self, query: E) -> Result<Vec<MySqlRow>>
+    where
+        E: 'x + Execute<'q, 'a, MySql>,
+        'e: 'x,
+        'q: 'x,
+        'a: 'x,
+    {
+        self.0.fetch_all(query)
+    }
+
+    #[inline]
+    fn fetch_optional<'x, 'e, 'q, 'a, E>(&'e mut self, query: E) -> Result<Option<MySqlRow>>
+    where
+        E: 'x + Execute<'q, 'a, MySql>,
+        'e: 'x,
+        'q: 'x,
+        'a: 'x,
+    {
+        self.0.fetch_optional(query)
+    }
+}

sqlx/src/query_as.rs

@@ -6,7 +6,7 @@ use sqlx_core::{Execute, Executor, FromRow, TypeEncode};
 use crate::{query, Arguments, Database, DefaultRuntime, Query, Runtime};
 
 pub struct QueryAs<'q, 'a, O, Db: Database, Rt: Runtime = DefaultRuntime> {
-    inner: Query<'q, 'a, Db, Rt>,
+    pub(crate) inner: Query<'q, 'a, Db, Rt>,
     output: PhantomData<O>,
 }