pg.ddx.io pgdogdev/pgdog GitHub issues and pull requests
help / color / mirror / Atom feedFrom: levkk (@levkk) <noreply+levkk@github.com>
To: pgdogdev/pgdog <noreply+pgdogdev-pgdog@github.com>
Subject: [pgdogdev/pgdog] PR #2068: fix: extra ReadyForQuery in shard key update transaction
Date: Wed, 18 Nov 2026 22:19:01 +0000
Message-ID: <gh-pgdogdev-pgdog-2068@github.com> (raw)
fix #2057
We weren't draining servers when an error was returned during a sharding key update. This caused them to send the remaining `ReadyForQuery` on the following request.
inline patch 1: pgdog/src/frontend/client/query_engine/multi_step/test/update.rs, pgdog/src/frontend/client/query_engine/multi_step/update.rs (+129/-0 lines) download inline-1.patch
diff --git a/pgdog/src/frontend/client/query_engine/multi_step/test/update.rs b/pgdog/src/frontend/client/query_engine/multi_step/test/update.rs
index 4676f168d..795905792 100644
--- a/pgdog/src/frontend/client/query_engine/multi_step/test/update.rs
+++ b/pgdog/src/frontend/client/query_engine/multi_step/test/update.rs
@@ -347,6 +347,127 @@ async fn test_move_rows_simple() {
});
}
+async fn failed_move_recovers(predicate: &str, expected_error: &str) {
+ let mut client = TestClient::new_rewrites(Parameters::default()).await;
+
+ for extended in [false, true] {
+ for returning in ["", " RETURNING id"] {
+ let source = client.random_id_for_shard(0);
+ let destination = client.random_id_for_shard(1);
+
+ for query in [
+ "BEGIN".to_owned(),
+ format!("INSERT INTO sharded (id) VALUES ({source}), ({destination})"),
+ "SAVEPOINT move".to_owned(),
+ ] {
+ client.send_simple(Query::new(query)).await;
+ client.read_until('Z').await.expect("setup succeeds");
+ }
+
+ if extended {
+ client
+ .send(Parse::new_anonymous(&format!(
+ "UPDATE sharded SET id = $1 WHERE id = $2{predicate}{returning}"
+ )))
+ .await;
+ client
+ .send(Bind::new_params(
+ "",
+ &[
+ Parameter::new(destination.to_string().as_bytes()),
+ Parameter::new(source.to_string().as_bytes()),
+ ],
+ ))
+ .await;
+ client.send(Execute::new()).await;
+ client.send(Sync).await;
+ client
+ .try_process()
+ .await
+ .expect("recoverable update error");
+ } else {
+ client
+ .send_simple(Query::new(format!(
+ "UPDATE sharded SET id = {destination} WHERE id = {source}{predicate}{returning}"
+ )))
+ .await;
+ }
+
+ let reply = client.read_until('E').await.expect("update error");
+ let error =
+ expect_message!(reply.last().expect("error response").clone(), ErrorResponse);
+ assert!(error.message.contains(expected_error), "{error:?}");
+ assert_eq!(
+ expect_message!(client.read().await, ReadyForQuery).status,
+ 'E'
+ );
+ assert!(
+ !client.engine.backend.has_more_messages(),
+ "internal query responses must be drained before reporting the error"
+ );
+ assert!(client.client.transaction.expect("open transaction").error());
+
+ // Each following response must start with its own CommandComplete,
+ // without a leftover ReadyForQuery from the failed internal query.
+ for (query, command, status) in [
+ ("ROLLBACK TO SAVEPOINT move".to_owned(), "ROLLBACK", 'T'),
+ (
+ format!("DELETE FROM sharded WHERE id = {source}"),
+ "DELETE 1",
+ 'T',
+ ),
+ ("COMMIT".to_owned(), "COMMIT", 'I'),
+ ] {
+ client.send_simple(Query::new(query)).await;
+ assert_eq!(
+ expect_message!(client.read().await, CommandComplete).command(),
+ command
+ );
+ assert_eq!(
+ expect_message!(client.read().await, ReadyForQuery).status,
+ status
+ );
+ assert!(
+ !client
+ .client
+ .transaction
+ .is_some_and(|transaction| transaction.error())
+ );
+ }
+
+ client
+ .send_simple(Query::new(format!(
+ "SELECT id FROM sharded WHERE id IN ({source}, {destination})"
+ )))
+ .await;
+ expect_message!(client.read().await, RowDescription);
+ assert_eq!(
+ expect_message!(client.read().await, DataRow).get::<i64>(0, Format::Text),
+ Some(destination)
+ );
+ expect_message!(client.read().await, CommandComplete);
+ expect_message!(client.read().await, ReadyForQuery);
+
+ client
+ .send_simple(Query::new(format!(
+ "DELETE FROM sharded WHERE id = {destination}"
+ )))
+ .await;
+ client.read_until('Z').await.expect("cleanup succeeds");
+ }
+ }
+}
+
+#[tokio::test]
+async fn test_failed_move_insert_recovers() {
+ failed_move_recovers("", "23505").await;
+}
+
+#[tokio::test]
+async fn test_failed_move_delete_recovers() {
+ failed_move_recovers(" AND nonexistent_update_column = 1", "42703").await;
+}
+
#[tokio::test]
async fn test_move_rows_extended() {
let mut client = TestClient::new_rewrites(Parameters::default()).await;
diff --git a/pgdog/src/frontend/client/query_engine/multi_step/update.rs b/pgdog/src/frontend/client/query_engine/multi_step/update.rs
index da56b4024..fbd65b1b0 100644
--- a/pgdog/src/frontend/client/query_engine/multi_step/update.rs
+++ b/pgdog/src/frontend/client/query_engine/multi_step/update.rs
@@ -41,6 +41,14 @@ impl<'a> UpdateMulti<'a> {
Err(err) => {
// These are recoverable with a ROLLBACK.
if matches!(err, Error::Update(_) | Error::Execution(_)) {
+ // Drain backends and set transaction error state.
+ while self.engine.backend.has_more_messages() {
+ self.engine.read_server_message().await?;
+ }
+ if let Some(transaction) = context.transaction.as_mut() {
+ transaction.set_error();
+ }
+
self.engine
.error_response(context, client_request, ErrorResponse::from_err(&err))
.await?;
view thread (6+ messages) latest in thread
Message-ID: <gh-pgdogdev-pgdog-2068@github.com>
Permalink: ../gh-pgdogdev-pgdog-2068@github.com/
· ·
This inbox is served by DDX for PostgreSQL; see mirroring instructions
for how to clone and mirror all data and code used for this inbox