Fix a bug where subsequent requests would fail after a failed CSV import on postgres

fixes #788

Author: lovasoa

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 - Add support for HTTP Basic Authentication in the [fetch](https://sql-page.com/documentation.sql?component=fetch#component) function.
 - Fix a bug where the table component would not add the right css classes to table cells.
+- Better error messages when a CSV import fails (using a `copy` statement and a file upload).
+- Fix a bug where subsequent requests would fail after a failed CSV import on postgres (https://github.com/sqlpage/SQLPage/issues/788)
 
 ## 0.32.1 (2025-01-03)
 

Cargo.lock

@@ -18,7 +18,7 @@ panic = "abort"
 codegen-units = 2
 
 [dependencies]
-sqlx = { package = "sqlx-oldapi", version = "0.6.38", features = [
+sqlx = { package = "sqlx-oldapi", version = "0.6.39", features = [
     "any",
     "runtime-actix-rustls",
     "sqlite",

Cargo.toml

@@ -146,15 +146,24 @@ pub(super) async fn run_csv_import(
     csv_import: &CsvImport,
     request: &RequestInfo,
 ) -> anyhow::Result<()> {
-    let file_path = request
+    let named_temp_file = &request
         .uploaded_files
         .get(&csv_import.uploaded_file)
-        .ok_or_else(|| anyhow::anyhow!("File not found"))?
-        .file
-        .path();
-    let file = tokio::fs::File::open(file_path)
-        .await
-        .with_context(|| "opening csv")?;
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "The request does not contain a field named {:?} with an uploaded file.\n\
+                Please check that :\n\
+                 - you have selected a file to upload, \n\
+                 - the form field name is correct.",
+                csv_import.uploaded_file
+            )
+        })?
+        .file;
+    let file_path = named_temp_file.path();
+    let file_name = file_path.file_name().unwrap_or_default();
+    let file = tokio::fs::File::open(file_path).await.with_context(|| {
+        format!("The CSV file {file_name:?} was uploaded correctly, but could not be opened",)
+    })?;
     let buffered = tokio::io::BufReader::new(file);
     // private_get_mut is not supposed to be used outside of sqlx, but it is the only way to
     // access the underlying connection
@@ -165,9 +174,9 @@ pub(super) async fn run_csv_import(
         _ => run_csv_import_insert(db, csv_import, buffered).await,
     }
     .with_context(|| {
+        let table_name = &csv_import.table_name;
         format!(
-            "running CSV import from {} to {}",
-            csv_import.uploaded_file, csv_import.table_name
+            "{file_name:?} was uploaded correctly, but its records could not be imported into the table {table_name}"
         )
     })
 }
@@ -179,13 +188,26 @@ async fn run_csv_import_postgres(
     csv_import: &CsvImport,
     file: impl AsyncRead + Unpin + Send,
 ) -> anyhow::Result<()> {
+    log::debug!("Running CSV import with postgres");
     let mut copy_transact = db
         .copy_in_raw(csv_import.query.as_str())
         .await
-        .with_context(|| "running COPY IN")?;
-    copy_transact.read_from(file).await?;
-    copy_transact.finish().await?;
-    Ok(())
+        .with_context(|| "The postgres COPY FROM STDIN command failed.")?;
+    log::debug!("Copy transaction created");
+    match copy_transact.read_from(file).await {
+        Ok(_) => {
+            log::debug!("Copy transaction finished successfully");
+            copy_transact.finish().await?;
+            Ok(())
+        }
+        Err(e) => {
+            log::debug!("Copy transaction failed with error: {e}");
+            copy_transact
+                .abort("The COPY FROM STDIN command failed.")
+                .await?;
+            Err(e.into())
+        }
+    }
 }
 
 async fn run_csv_import_insert(

src/webserver/database/csv_import.rs

@@ -54,7 +54,7 @@ pub fn stream_query_results_with_conn<'a>(
                 ParsedStatement::CsvImport(csv_import) => {
                     let connection = take_connection(&request.app_state.db, db_connection).await?;
                     log::debug!("Executing CSV import: {:?}", csv_import);
-                    run_csv_import(connection, csv_import, request).await?;
+                    run_csv_import(connection, csv_import, request).await.with_context(|| format!("Failed to import the CSV file {:?} into the table {:?}", csv_import.uploaded_file, csv_import.table_name))?;
                 },
                 ParsedStatement::StmtWithParams(stmt) => {
                     let query = bind_parameters(stmt, request, db_connection).await?;

src/webserver/database/execute_queries.rs

@@ -636,6 +636,65 @@ async fn test_official_website_basic_auth_example() {
     );
 }
 
+/// https://github.com/sqlpage/SQLPage/issues/788
+#[actix_web::test]
+async fn test_failed_copy_followed_by_query() -> actix_web::Result<()> {
+    let app_data = make_app_data().await;
+    let big_csv = "col1,col2\nval1,val2\n".repeat(1000);
+    let req = get_request_to_with_data(
+        "/tests/sql_test_files/error_failed_to_import_the_csv.sql",
+        app_data.clone(),
+    )
+    .await?
+        .insert_header(("content-type", "multipart/form-data; boundary=1234567890"))
+        .set_payload(format!(
+            "--1234567890\r\n\
+            Content-Disposition: form-data; name=\"recon_csv_file_input\"; filename=\"data.csv\"\r\n\
+            Content-Type: text/csv\r\n\
+            \r\n\
+            {big_csv}\r\n\
+            --1234567890--\r\n"
+        ))
+        .to_srv_request();
+    let resp = main_handler(req).await?;
+
+    assert_eq!(resp.status(), StatusCode::OK);
+    let body = test::read_body(resp).await;
+    let body_str = String::from_utf8(body.to_vec()).unwrap();
+    assert!(
+        body_str.contains("error"),
+        "{body_str}\nexpected to contain error message"
+    );
+
+    // On postgres, the error message should contain  "The postgres COPY FROM STDIN command failed"
+    if matches!(app_data.db.to_string().to_lowercase().as_str(), "postgres") {
+        assert!(
+            body_str.contains("The postgres COPY FROM STDIN command failed"),
+            "{body_str}\nexpected to contain: The postgres COPY FROM STDIN command failed"
+        );
+    }
+    // Now make other requests to verify the connection is still usable
+    for path in [
+        "/tests/sql_test_files/it_works_lower.sql",
+        "/tests/sql_test_files/it_works_simple.sql",
+        "/tests/sql_test_files/it_works_path.sql",
+    ] {
+        let req = get_request_to_with_data(path, app_data.clone())
+            .await?
+            .to_srv_request();
+        let resp = main_handler(req).await?;
+
+        assert_eq!(resp.status(), StatusCode::OK);
+        let body = test::read_body(resp).await;
+        let body_str = String::from_utf8(body.to_vec()).unwrap();
+        assert!(
+            body_str.contains("It works !"),
+            "{body_str}\nexpected to contain: It works !"
+        );
+    }
+    Ok(())
+}
+
 async fn get_request_to_with_data(
     path: &str,
     data: actix_web::web::Data<AppState>,

tests/index.rs

@@ -0,0 +1,2 @@
+-- https://github.com/sqlpage/SQLPage/issues/788
+copy this_table_does_not_exist (csv) from 'recon_csv_file_input' DELIMITER '*' CSV;