LogicalTransactions in frontend Client

integration/go/go_pgx/load_balancer_test.go

@@ -231,10 +231,18 @@ outer:
 }
 
 func prewarm(t *testing.T, pool *pgxpool.Pool) {
+	ctx := context.Background()
 	for range 25 {
-		for _, q := range []string{"BEGIN", "SELECT 1", "COMMIT", "SELECT 1"} {
-			_, err := pool.Exec(context.Background(), q)
-			assert.NoError(t, err)
-		}
+		// transaction `BEGIN; SELECT 1; COMMIT;`
+		tx, err := pool.Begin(ctx)
+		assert.NoError(t, err)
+		_, err = tx.Exec(ctx, "SELECT 1")
+		assert.NoError(t, err)
+		err = tx.Commit(ctx)
+		assert.NoError(t, err)
+
+		// no-transaction `SELECT 1;`
+		_, err = pool.Exec(ctx, "SELECT 1")
+		assert.NoError(t, err)
 	}
 }

integration/load_balancer/run.sh

@@ -10,7 +10,7 @@ export PGHOST=127.0.0.1
 export PGDATABASE=postgres
 export PGPASSWORD=postgres
 
-docker-compose up -d
+docker compose up -d
 
 
 echo "Waiting for Postgres to be ready"
@@ -45,4 +45,4 @@ popd
 
 killall pgdog
 
-docker-compose down
+docker compose down

pgdog/src/frontend/client/engine/context.rs

@@ -1,5 +1,7 @@
 use crate::{
-    frontend::{client::Inner, Buffer, Client, PreparedStatements},
+    frontend::{
+        client::Inner, logical_transaction::LogicalTransaction, Buffer, Client, PreparedStatements,
+    },
     net::Parameters,
 };
 
@@ -13,7 +15,7 @@ pub struct EngineContext<'a> {
     /// Client parameters.
     pub(super) params: &'a Parameters,
     /// Is the client inside a transaction?
-    pub(super) in_transaction: bool,
+    pub(super) logical_transaction: &'a LogicalTransaction,
     /// Messages currently in client's buffer.
     pub(super) buffer: &'a Buffer,
 }
@@ -23,7 +25,7 @@ impl<'a> EngineContext<'a> {
         Self {
             prepared_statements: &mut client.prepared_statements,
             params: &client.params,
-            in_transaction: client.in_transaction,
+            logical_transaction: &client.logical_transaction,
             connected: inner.connected(),
             buffer: &client.request_buffer,
         }

pgdog/src/frontend/client/engine/mod.rs

@@ -54,7 +54,10 @@ impl<'a> Engine<'a> {
                 'S' => {
                     if only_close || only_sync && !self.context.connected {
                         messages.push(
-                            ReadyForQuery::in_transaction(self.context.in_transaction).message()?,
+                            ReadyForQuery::in_transaction(
+                                self.context.logical_transaction.in_transaction(),
+                            )
+                            .message()?,
                         )
                     }
                 }
@@ -73,7 +76,7 @@ impl<'a> Engine<'a> {
 #[cfg(test)]
 mod test {
     use crate::{
-        frontend::{Buffer, PreparedStatements},
+        frontend::{logical_transaction::LogicalTransaction, Buffer, PreparedStatements},
         net::{Parameters, Parse, Sync},
     };
 
@@ -93,11 +96,13 @@ mod test {
             Sync.into(),
         ]);
 
+        let logical_transaction = LogicalTransaction::new();
+
         let context = EngineContext {
             connected: false,
             prepared_statements: &mut prepared,
             params: &params,
-            in_transaction: false,
+            logical_transaction: &logical_transaction,
             buffer: &buf,
         };
 

pgdog/src/frontend/client/inner.rs

@@ -6,8 +6,9 @@ use crate::{
         Error as BackendError,
     },
     frontend::{
-        buffer::BufferedQuery, router::Error as RouterError, Buffer, Command, Comms,
-        PreparedStatements, Router, RouterContext, Stats,
+        buffer::BufferedQuery, logical_transaction::LogicalTransaction,
+        router::Error as RouterError, Buffer, Command, Comms, PreparedStatements, Router,
+        RouterContext, Stats,
     },
     net::Parameters,
     state::State,
@@ -58,7 +59,7 @@ impl Inner {
         buffer: &mut Buffer,
         prepared_statements: &mut PreparedStatements,
         params: &Parameters,
-        in_transaction: bool,
+        logical_transaction: &LogicalTransaction,
     ) -> Result<Option<&Command>, RouterError> {
         let command = self
             .backend
@@ -67,11 +68,11 @@ impl Inner {
             .map(|cluster| {
                 // Build router context.
                 let context = RouterContext::new(
-                    buffer,              // Query and parameters.
-                    cluster,             // Cluster configuration.
-                    prepared_statements, // Prepared statements.
-                    params,              // Client connection parameters.
-                    in_transaction,      // Client in explcitely started transaction.
+                    buffer,                               // Query and parameters.
+                    cluster,                              // Cluster configuration.
+                    prepared_statements,                  // Prepared statements.
+                    params,                               // Client connection parameters.
+                    logical_transaction.in_transaction(), // Client in explcitely started transaction.
                 )?;
                 self.router.query(context)
             })