What is cursor in SQL?

What is cursor in SQL?

Welcome to another informative post on codedamn, where we strive to make complex programming concepts easily digestible. SQL, or Structured Query Language, is the standard language for communicating with relational databases. Today, we’ll venture beyond basic SQL queries and delve into the concept of cursors—what they are, how they work, their types, and how to use them. Let’s get started.


Picture this: You’ve mastered SQL queries and can effortlessly join tables, filter records, and update fields. But now you’ve been tasked with a more complex operation, perhaps one that involves looping through individual rows to perform condition-based actions. This is where SQL cursors come into play.

What is a Cursor?

Formal Definition

A cursor in SQL is a database object that allows you to traverse records in a result set row-by-row, rather than fetching the entire set in one go. Essentially, it acts like a pointer that facilitates sequential access to data.


Cursors are particularly useful when you need to perform row-by-row manipulations that can’t be accomplished with standard SQL queries. For example, you might use a cursor to iterate through rows to perform calculations based on previous rows, or to update records conditionally.

Comparison with Standard Query Operations

Unlike conventional SQL queries that retrieve entire sets of records at once, cursors provide granular control over each row. However, this row-by-row traversal generally makes cursors slower and more resource-intensive.

Basic Anatomy

The life cycle of a cursor involves four main steps: declaration, opening, fetching, and closing.

  1. Declaration: Declare the cursor with a SQL SELECT statement.
  2. Opening: Open the cursor to store data retrieved.
  3. Fetching: Fetch data row-by-row.
  4. Closing: Close the cursor when done.

Types of Cursors

SQL cursors can be broadly categorized into two types based on their initiation—implicit and explicit—and into four types based on their behavior—static, dynamic, forward-only, and scrollable.

Implicit vs. Explicit Cursors

Definition and Differences

  • Implicit Cursors: These are automatically created by SQL whenever a SELECT query returns a result set. You don’t have control over implicit cursors.
  • Explicit Cursors: These are user-defined cursors where you explicitly declare, open, fetch, and close them.

Example Code

For an explicit cursor:

DECLARE my_cursor CURSOR FOR SELECT column1 FROM table1;
OPEN my_cursor;
FETCH NEXT FROM my_cursor;
CLOSE my_cursor;

Static, Dynamic, Forward-Only, and Scrollable Cursors


  • Static Cursors: They take a snapshot of the data, allowing you to scroll forward and backward, but changes to the database are not reflected.
  • Dynamic Cursors: They reflect changes made to the database, allowing for real-time data manipulation.
  • Forward-Only: You can only scroll forward through the record set.
  • Scrollable: You can scroll both forward and backward.


  • Static: Good for reports where data consistency is needed.
  • Dynamic: Useful for dashboards where real-time data is crucial.
  • Forward-Only: Best for operations that don’t require backward traversal.
  • Scrollable: Useful when both forward and backward navigation is required.

Example Code

-- For a Static Cursor
DECLARE static_cursor STATIC CURSOR FOR SELECT column1 FROM table1;

-- For a Dynamic Cursor
DECLARE dynamic_cursor DYNAMIC CURSOR FOR SELECT column1 FROM table1;

Declaring and Opening Cursors


To declare and open a cursor, you generally use the DECLARE and OPEN SQL statements, specifying the SQL query that the cursor will traverse.

Example Code

-- Declare a cursor
DECLARE sample_cursor CURSOR FOR SELECT name FROM employees WHERE department = 'HR';

-- Open the cursor
OPEN sample_cursor;

Fetching Data with Cursors

Single-row Fetch


Fetching a single row using a cursor in SQL involves a series of steps: declaring a cursor, opening it, fetching the row, and then eventually closing the cursor. The simplified syntax for fetching a single row can look like this:

DECLARE cursor_name CURSOR FOR SELECT_statement;
OPEN cursor_name;
FETCH cursor_name INTO variables;
CLOSE cursor_name;

Example Code

Here’s a basic example where we fetch a single row from a table named Employees:

DECLARE @EmployeeID int, @EmployeeName varchar(255);
DECLARE single_row_cursor CURSOR FOR
SELECT EmployeeID, EmployeeName FROM Employees;
OPEN single_row_cursor;
FETCH NEXT FROM single_row_cursor INTO @EmployeeID, @EmployeeName;
PRINT 'Employee ID: ' + CAST(@EmployeeID AS varchar) + ', Employee Name: ' + @EmployeeName;
CLOSE single_row_cursor;

Multi-row Fetch


When fetching multiple rows, you’ll usually use a loop to iterate through the cursor:

DECLARE cursor_name CURSOR FOR SELECT_statement;
OPEN cursor_name;
FETCH NEXT FROM cursor_name INTO variables;
-- Your logic here
FETCH NEXT FROM cursor_name INTO variables;
CLOSE cursor_name;

Example Code

1DECLARE @EmployeeID int, @EmployeeName varchar(255);
2DECLARE multi_row_cursor CURSOR FOR
3SELECT EmployeeID, EmployeeName FROM Employees;
4OPEN multi_row_cursor;
5FETCH NEXT FROM multi_row_cursor INTO @EmployeeID, @EmployeeName;
8 PRINT 'Employee ID: ' + CAST(@EmployeeID AS varchar) + ', Employee Name: ' + @EmployeeName;
9 FETCH NEXT FROM multi_row_cursor INTO @EmployeeID, @EmployeeName;
11CLOSE multi_row_cursor;

Updating Data Using Cursors


Cursors are useful for updating data when the modification for each row depends on data from other rows, effectively making set-based solutions unsuitable.


Here’s the syntax for updating data using cursors:

DECLARE cursor_name CURSOR FOR SELECT_statement FOR UPDATE OF column_name;

Example Code

DECLARE update_cursor CURSOR FOR
SELECT Salary FROM Employees WHERE Department = 'HR' FOR UPDATE OF Salary;


Be cautious when using cursors for updates, as they can lock rows and potentially result in deadlocks.

Closing and Deallocating Cursors

Importance of Releasing Resources

Closing and deallocating cursors is crucial to free up resources, which helps maintain system performance.


CLOSE cursor_name;
DEALLOCATE cursor_name;

Example Code

CLOSE update_cursor;
DEALLOCATE update_cursor;

Error Handling

Types of Errors

Common errors include syntax errors and runtime errors like trying to fetch past the end of the cursor.

Error Handling Techniques

The TRY...CATCH block can be used to handle errors effectively:

-- Cursor operations here
PRINT 'An error occurred: ' + ERROR_MESSAGE();

Best Practices

When to Use Cursors


Use cursors when you need row-by-row processing that can’t be easily done using set-based operations.

Example Code

Refer to the earlier single-row fetch example for an appropriate use-case.

When to Avoid Cursors


For most data retrieval operations, set-based SQL queries are more efficient.

Example Code

UPDATE Employees SET Salary = Salary * 1.1 WHERE Department = 'HR';

Limitations and Caveats

  • Performance Overheads: Cursors can be resource-intensive.
  • Transaction Locking Risks: Using cursors for updates can lock rows.
  • Compatibility Issues: Cursor implementations can vary between different SQL databases.

Sharing is caring

Did you like what Pranav wrote? Thank them for their work by sharing it on social media.


No comments so far