avoid repeatedly acquiring and releasing connections when running a single SQL file

... and return better errors when we are getting too many requests

Author: lovasoa

CHANGELOG.md

@@ -10,6 +10,8 @@
  - Fix the default index page in MySQL. Fixes [#23](https://github.com/lovasoa/SQLpage/issues/23).
  - Add a new [map](https://sql.ophir.dev/documentation.sql?component=map#component) component to display a map with markers on it. Useful to display geographic data from PostGIS or Spatialite.
  - Add a new `icon` attribute to the [table](https://sql.ophir.dev/documentation.sql?component=table#component) component to display icons in the table.
+ - Fix `textarea` fields in the [form](https://sql.ophir.dev/documentation.sql?component=table#component) component to display the provided `value` attribute. Thanks Frank for the contribution !
+ - SQLPage now guarantees that a single web request will be handled by a single database connection. Previously, connections were repeatedly taken and put back to the connection pool between each statement, preventing the use of temporary tables, transactions, and other connection-specific features such as [`last_insert_rowid`](https://www.sqlite.org/lang_corefunc.html#last_insert_rowid). This makes it much easier to keep state between SQL statements in a single `.sql` file. Please report any performance regression you might encounter. See [the many-to-many relationship example](./examples/modeling%20a%20many%20to%20many%20relationship%20with%20a%20form/).
 
 ## 0.7.2 (2023-07-10)
 

src/webserver/database/mod.rs

@@ -117,12 +117,14 @@ pub async fn stream_query_results_direct<'a>(
     request: &'a RequestInfo,
 ) -> anyhow::Result<BoxStream<'a, anyhow::Result<Either<AnyQueryResult, AnyRow>>>> {
     Ok(async_stream::stream! {
+        let mut connection = db.connection.acquire().await
+            .with_context(|| anyhow::anyhow!("Unable to acquire a database connection to execute the SQL file. All of the {} {:?} connections are busy.", db.connection.size(), db.connection.any_kind()))?;
         for res in &sql_file.statements {
             match res {
                 Ok(stmt)=>{
                     let query = bind_parameters(stmt, request)
                         .with_context(|| format!("Unable to bind parameters to the SQL statement: {stmt}"))?;
-                    let mut stream = query.fetch_many(&db.connection);
+                    let mut stream = query.fetch_many(&mut connection);
                     while let Some(elem) = stream.next().await {
                         yield elem.with_context(|| format!("Error while running SQL: {stmt}"))
                     }

src/webserver/http.rs

@@ -253,6 +253,15 @@ fn send_anyhow_error(e: &anyhow::Error, resp_send: tokio::sync::oneshot::Sender<
             ));
         }
     };
+    if let Some(sqlx::Error::PoolTimedOut) = e.downcast_ref() {
+        // People are HTTP connections faster than we can open SQL connections. Ask them to slow down politely.
+        use rand::Rng;
+        *resp.status_mut() = StatusCode::SERVICE_UNAVAILABLE;
+        resp.headers_mut().insert(
+            header::RETRY_AFTER,
+            header::HeaderValue::from(rand::thread_rng().gen_range(1..=15)),
+        );
+    }
     resp_send
         .send(resp)
         .unwrap_or_else(|_| log::error!("could not send headers"));