If you’ve been working with SQL for a while, you’ve probably heard someone mention cursors, usually followed by a warning to avoid them. Maybe you’ve used them yourself. But what exactly are cursors, and why do they get such a bad rap? Let’s take a look at what cursors are, how they work, and when (if ever) you should actually use them.
Database Concepts
What is a Derived Table in SQL?
If you’ve been writing SQL for a while, you’ve probably run into situations where you need to query data that’s already been aggregated, filtered, or transformed in some way. Maybe you need to calculate an average first, then find all the rows above that average. Or perhaps you need to group data by category, then filter those grouped results.
This is where derived tables can come in handy. Derived tables let you build queries in layers, where one query’s output becomes another query’s input, all within a single SQL statement.
What is a Temp Table?
Need a high-performance, disposable workspace for your SQL queries? Meet temporary tables, also known simply as temp tables. As their name implies, these tables offer a short-lived storage solution, ideal for holding intermediate data or simplifying complex multi-step processing. They exist just long enough to get the job done, providing a handy scratch pad that vanishes automatically to keep your database clean.
What is a Checkpoint in a Database?
If you’ve ever wondered how databases manage to recover your data after a crash without losing everything you just did, checkpoints are a big part of that. They’re one of those behind-the-scenes mechanisms that keep databases running smoothly, even when things go wrong.
What is a Rollback in SQL?
In SQL, a rollback is a command that reverses all the changes made during a transaction. When you execute a ROLLBACK statement, the database management system undoes all the Data Manipulation Language (DML) operations (such as INSERT, UPDATE, and DELETE) that happened since the transaction began (or since a specified savepoint), restoring the database to its previous consistent state.
What is a Commit in SQL?
If you’ve spent any time working with databases, you’ve probably noticed that most of your SQL statements just work. You run an INSERT, UPDATE, or DELETE, and the changes happen. You don’t need to do anything special to make them stick. Your changes were committed automatically as soon as you ran the statement. No need for a separate COMMIT keyword.
But then there are other cases where you need to explicitly use a COMMIT keyword.
So why is COMMIT required in some cases and not in others?
What is Transaction Starvation?
Transaction starvation is one of those database problems that can sneak up on you when you least expect it. It happens when a transaction sits waiting for resources it needs to complete, but those resources never become available, or at least not for an unreasonably long time. The transaction essentially “starves” while other transactions keep getting priority access to the resources it needs.
What is a Deadlock Victim?
Anyone who manages a high-traffic database is almost certainly familiar with the dreaded deadlock error. When this circular dependency freezes concurrent operations, your database management system must intervene by selecting a deadlock victim – one transaction it immediately terminates and rolls back.
But what exactly is a “deadlock victim”, and why does your database seem to be picking on certain transactions? Let’s take a look, and explore why databases make these tough decisions.
What is Pessimistic Concurrency Control?
When multiple users or processes of a database are trying to access and modify the same data at the same time, things can get messy pretty quickly. That’s where concurrency control comes in. This the set of strategies databases use to make sure everyone plays nicely together. One of the classic strategies for managing this is called pessimistic concurrency control. The name might sound gloomy, but it’s actually a very practical approach to keeping your data consistent and reliable.
What is Optimistic Concurrency Control?
Imagine you’re working on a shared Google Doc with a colleague. You both open the same document, make your edits, and hit save. Now imagine if every time someone wanted to edit the document, they had to lock it so nobody else could even read it while they were making changes. That would be pretty frustrating, right? This is essentially the problem that optimistic concurrency control tries to solve in databases.