Transaction handling in GraphQL - Step-by-Step Execution

Concept Flow - Transaction handling

Start Transaction

↓

Execute Queries

↓

Check for Errors?

Yes→Rollback Transaction

↓

End Transaction

↓

Commit Transaction

This flow shows how a transaction starts, runs queries, checks for errors, and either commits or rolls back.

Execution Sample

GraphQL

mutation {
  startTransaction
  updateUser(id: 1, name: "Alice")
  updateBalance(userId: 1, amount: 100)
  commitTransaction
}

This GraphQL mutation starts a transaction, updates user data and balance, then commits the transaction.

Execution Table

Step	Action	Result	Transaction State
1	startTransaction	Transaction started	Active
2	updateUser(id:1, name:"Alice")	User updated	Active
3	updateBalance(userId:1, amount:100)	Balance updated	Active
4	commitTransaction	Transaction committed	Committed
5	End	No more actions	Ended

💡 Transaction ends after commit; all changes saved.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
Transaction State	None	Active	Active	Active	Committed	Ended
User Name	OldName	OldName	Alice	Alice	Alice	Alice
User Balance	OldBalance	OldBalance	OldBalance	OldBalance + 100	OldBalance + 100	OldBalance + 100

Key Moments - 3 Insights

Why do we need to start a transaction before updating data?

Starting a transaction groups multiple changes so they all succeed or fail together, as shown in steps 1-4 in the execution_table.

What happens if an error occurs during updateBalance?

If an error occurs, the transaction should rollback to undo all changes, preventing partial updates. This is the 'Rollback Transaction' path in the concept_flow.

Why commit the transaction at the end?

Committing saves all changes permanently. Without commit, changes remain temporary and can be lost, as shown in step 4 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the Transaction State after step 3?

A Active

B Committed

C Ended

D None

💡 Hint

Check the 'Transaction State' column for step 3 in the execution_table.

At which step does the transaction get committed?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for 'commitTransaction' action in the execution_table.

If an error occurs at step 3, what should happen next?

A Commit the transaction

B Rollback the transaction

C Ignore the error and continue

D Start a new transaction

💡 Hint

Refer to the concept_flow where errors lead to rollback.

Concept Snapshot

Transaction handling groups multiple database operations.
Start a transaction before changes.
If all succeed, commit to save.
If any fail, rollback to undo.
Ensures data stays consistent.

Full Transcript

Transaction handling in GraphQL involves starting a transaction, performing multiple updates, and then either committing or rolling back based on success or failure. The process begins with startTransaction, followed by executing queries like updateUser and updateBalance. If all queries succeed, commitTransaction saves the changes permanently. If any query fails, rollbackTransaction undoes all changes to keep data consistent. This ensures that partial updates do not corrupt the database. The execution table shows each step and the transaction state changes from Active to Committed. Key moments include understanding why transactions start, what happens on errors, and why committing is necessary. The visual quiz tests understanding of transaction states and error handling.