breaking: make offline optional to allow building without serde (#4077)

* refactor(postgres): split describe into resolve and explain

* refactor(postgres): remove duplicated code from resolve and explain

* breaking: make `offline` optional to allow building without `serde`

sqlx-sqlite/Cargo.toml

@@ -77,7 +77,7 @@ uuid = { workspace = true, optional = true }
 
 url = { version = "2.2.2" }
 percent-encoding = "2.1.0"
-serde_urlencoded = "0.7"
+form_urlencoded = "1.2.2"
 
 flume = { version = "0.11.0", default-features = false, features = ["async"] }
 

sqlx-sqlite/src/any.rs

@@ -7,7 +7,7 @@ use futures_core::stream::BoxStream;
 use futures_util::{FutureExt, StreamExt, TryFutureExt, TryStreamExt};
 
 use sqlx_core::any::{
-    Any, AnyArguments, AnyColumn, AnyConnectOptions, AnyConnectionBackend, AnyQueryResult, AnyRow,
+    AnyArguments, AnyColumn, AnyConnectOptions, AnyConnectionBackend, AnyQueryResult, AnyRow,
     AnyStatement, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind,
 };
 use sqlx_core::sql_str::SqlStr;
@@ -16,7 +16,6 @@ use crate::arguments::SqliteArgumentsBuffer;
 use crate::type_info::DataType;
 use sqlx_core::connection::{ConnectOptions, Connection};
 use sqlx_core::database::Database;
-use sqlx_core::describe::Describe;
 use sqlx_core::executor::Executor;
 use sqlx_core::transaction::TransactionManager;
 use std::pin::pin;
@@ -140,7 +139,11 @@ impl AnyConnectionBackend for SqliteConnection {
         })
     }
 
-    fn describe(&mut self, sql: SqlStr) -> BoxFuture<'_, sqlx_core::Result<Describe<Any>>> {
+    #[cfg(feature = "offline")]
+    fn describe(
+        &mut self,
+        sql: SqlStr,
+    ) -> BoxFuture<'_, sqlx_core::Result<sqlx_core::describe::Describe<sqlx_core::any::Any>>> {
         Box::pin(async move { Executor::describe(self, sql).await?.try_into_any() })
     }
 }

sqlx-sqlite/src/connection/establish.rs

@@ -93,10 +93,15 @@ impl EstablishParams {
 
         if !query_params.is_empty() {
             filename = format!(
-                "file:{}?{}",
+                "file:{}?",
                 percent_encoding::percent_encode(filename.as_bytes(), NON_ALPHANUMERIC),
-                serde_urlencoded::to_string(&query_params).unwrap()
             );
+
+            // Suffix serializer automatically handles `&` separators for us.
+            let filename_len = filename.len();
+            filename = form_urlencoded::Serializer::for_suffix(filename, filename_len)
+                .extend_pairs(query_params)
+                .finish();
         }
 
         let filename = CString::new(filename).map_err(|_| {

sqlx-sqlite/src/connection/executor.rs

@@ -4,7 +4,6 @@ use crate::{
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
 use futures_util::{stream, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
-use sqlx_core::describe::Describe;
 use sqlx_core::error::Error;
 use sqlx_core::executor::{Execute, Executor};
 use sqlx_core::sql_str::SqlStr;
@@ -89,7 +88,11 @@ impl<'c> Executor<'c> for &'c mut SqliteConnection {
     }
 
     #[doc(hidden)]
-    fn describe<'e>(self, sql: SqlStr) -> BoxFuture<'e, Result<Describe<Sqlite>, Error>>
+    #[cfg(feature = "offline")]
+    fn describe<'e>(
+        self,
+        sql: SqlStr,
+    ) -> BoxFuture<'e, Result<sqlx_core::describe::Describe<Sqlite>, Error>>
     where
         'c: 'e,
     {

sqlx-sqlite/src/connection/worker.rs

@@ -8,18 +8,16 @@ use futures_intrusive::sync::{Mutex, MutexGuard};
 use sqlx_core::sql_str::SqlStr;
 use tracing::span::Span;
 
-use sqlx_core::describe::Describe;
 use sqlx_core::error::Error;
 use sqlx_core::transaction::{
     begin_ansi_transaction_sql, commit_ansi_transaction_sql, rollback_ansi_transaction_sql,
 };
 use sqlx_core::Either;
 
-use crate::connection::describe::describe;
 use crate::connection::establish::EstablishParams;
 use crate::connection::execute;
 use crate::connection::ConnectionState;
-use crate::{Sqlite, SqliteArguments, SqliteQueryResult, SqliteRow, SqliteStatement};
+use crate::{SqliteArguments, SqliteQueryResult, SqliteRow, SqliteStatement};
 
 #[cfg(feature = "deserialize")]
 use crate::connection::deserialize::{deserialize, serialize, SchemaName, SqliteOwnedBuf};
@@ -57,9 +55,10 @@ enum Command {
         query: SqlStr,
         tx: oneshot::Sender<Result<SqliteStatement, Error>>,
     },
+    #[cfg(feature = "offline")]
     Describe {
         query: SqlStr,
-        tx: oneshot::Sender<Result<Describe<Sqlite>, Error>>,
+        tx: oneshot::Sender<Result<sqlx_core::describe::Describe<crate::Sqlite>, Error>>,
     },
     Execute {
         query: SqlStr,
@@ -157,8 +156,9 @@ impl ConnectionWorker {
                                 &shared.cached_statements_size,
                             );
                         }
+                        #[cfg(feature = "offline")]
                         Command::Describe { query, tx } => {
-                            tx.send(describe(&mut conn, query)).ok();
+                            tx.send(crate::connection::describe::describe(&mut conn, query)).ok();
                         }
                         Command::Execute {
                             query,
@@ -352,7 +352,11 @@ impl ConnectionWorker {
             .await?
     }
 
-    pub(crate) async fn describe(&mut self, query: SqlStr) -> Result<Describe<Sqlite>, Error> {
+    #[cfg(feature = "offline")]
+    pub(crate) async fn describe(
+        &mut self,
+        query: SqlStr,
+    ) -> Result<sqlx_core::describe::Describe<crate::Sqlite>, Error> {
         self.oneshot_cmd(|tx| Command::Describe { query, tx })
             .await?
     }