SQL Server recovery models define when database transactions are written to the transaction log. Understanding these models is critical for backup and recovery purposes as well as for how their behaviors impact the performance of queries.
Today we'll examine the differences between SQL Server's three official recovery models as well as an unofficial "fourth" recovery model that won't help in backup/recovery, but will help in performance of certain processes.
The only recovery model that can potentially save all of your data when something bad happens (NOTE: "potentially" because if you aren't taking enough and/or testing your backups, you might experience data loss).
Under the full recovery model, every transaction is written to the transaction log first, and then persisted to the actual database. This means if something disastrous happens to your server, as long as the change made its way into the transaction log AND your transaction log is readable AND your previous full/differential/log backups can be restored, you shouldn't experience any data loss (there are a lot of assumptions made with that statement though, so don't use this post as your only data loss prevention guide)
From a performance standpoint, full recovery is the slowest of the bunch because every transaction needs to be logged, and that creates some overhead. Might be good for your OLTP databases, maybe not so much for your analytical staging databases (assuming you can recreate that data).
While some people incorrectly believe that simple recovery means no writing to the transaction log (need proof that a database in simple recovery still writes to the trans log? Try running ROLLBACK TRANSACTION after a huge delete) it actually means that the transaction log is cleared as soon as SQL Server is done using it and data has made its way to disk.
Since the transaction log is cleared regularly, your overall log size can be smaller since space is regularly reused. Additionally, since that space is cleared you don't have to worry about backing it up.
No persistence of the transaction log means you won't be able to recover all of your data in case of server failure though. This is generally OK if you are using simple recovery in databases where its easy to recreate any data since your last full backup (eg. staging data where you can easily redo the transactions that were lost).
Simple recovery minimally logs as many transactions as possible, making the throughput faster. This works well in staging databases and for ETLs where data is in flux and can be easily recreated.
If Goldilocks thinks the full recovery model has too much logging, and the simple model not enough logging, then she'll find the amount of logging in the bulk-logged recovery model to be just right.
Under bulk-logged, most transactions are fully logged, allowing for data restoration of those fully logged transactions if the need arises. Bulk transactions however are minimally logged, allowing for better performance of things like bulk inserts (but no ability for restoration).
While restorations under the bulk-logged recovery model aren't as flexible as full recovery (eg. if the transaction log has any bulk transactions, you have to restore the whole transaction log instead of just up to a certain point), it does allow full logging for when most people need it and minimal logging for when most people don't need it. Meaning for certain situations you can have your cake and eat it too!
The Fourth Unofficial Recovery Model: In-Memory SCHEMA_ONLY Durability
The SCHEMA_ONLY durability setting on a memory optimized table isn't a recovery model. But it does behave a little bit like a recovery model in the sense that it defines how operations against your memory optimized table interact with your transaction log:
And that's the beauty of it, at least from a performance stand point. If you are willing to trade off the ability to recover data for performance, then the SCHEMA_ONLY durability fits the bill - so long transaction log overhead.
So while none of the official recovery models allow you to prevent writing to the transaction log, the SCHEMA_ONLY durability setting does!