Free Courses

A Dynamic SQLChallenge (32 minutes)

In this challenge, you are tasked with editing a stored procedure to gather data from multiple databases. What’s the most efficient way to do it? Try your hand at the challenge, then check out three different suggested solutions.

A Query Writing SQLChallenge: The Most Unique Names (23 minutes)

Flex your T-SQL skills: you’re challenged to write four different (but related) queries in this query writing challenge.

Auto Tuning with Automatic Plan Correction in Query Store (1 hour 8 minutes)

WARNING: I do NOT currently recommend enabling the Automatic Plan Correction feature due to issues described in my post, Automatic Plan Correction Could be a Great Auto Tuning Feature for SQL Server. Here’s why it Isn’t.

Want a built-in assistant performance tuner in SQL Server?

Try the course quiz anytime.

Deduplicate Indexes - Level 1 SQLChallenge (56 minutes)

Your challenge is to de-duplicate the indexes on a table in a sample database. Can you predict which indexes are the safest ones to drop?

Defuse the Deadlock SQLChallenge (23 minutes)

Sharpen your skills at fighting blocking and deadlocks.

Execution Plans: Partitioned Tables and Columnstore Indexes (1 hour 30 minutes)

Execution plans are incredibly helpful when it comes to tuning queries using partitioned indexes and columnstore indexes – but when you look closely, you’ll notice that some things are very weird!

Try the course quiz anytime.

Forcing Parallelism SQLChallenge (48 minutes)

A database administrator has changed Cost Threshold for Parallelism on the instance, and you’ve got a query that’s slowed down.

How Index Keys and Includes Work (1 hour)

Build your powers of index design by learning how indexes are structured in SQL Server.

Try the course quiz anytime.

How to Decipher CXPACKET Waits and Control Parallelism (4 hours)

Learn to tune parallelism and interpret CXPACKET waits in SQL Server.

Try the course quiz anytime.

How to Decode Memory Pressure (4 hours)

SQL Server doesn’t make it easy to see if your SQL Server is under memory pressure, or if someone goofed when configuring the memory settings on your critical production instances.

Index Design SQLChallenge - One Year Wonders (50 minutes)

This challenge comes in three possible levels of difficulty: choose one or work through them all!

Indexing for Windowing Functions (45 minutes)

Get the best performance for your windowing functions.

Learn Indexing by Solving Problems (7 hours 23 minutes)

SQL Server asks for a lot of indexes — but it does NOT always ask for the right index!

You need to know the essential principles of index design to create the best nonclustered index, filtered index, or indexed view to speed up your critical queries.

Problem Queries in Table Partitioning (1 hour 30 minutes)

Some queries may get slower after you partition your tables: the SQL Server optimizer doesn’t always use indexes the same way after those indexes are partitioned into chunks.

Query Tuning with Hints & Optimizer Hotfixes (2 hours 15 minutes)

In this course you’ll learn the pros and cons of using hints, trace flags, and scoped database configuration to tune your queries in SQL Server.

Try the course quizzes anytime: using hints, recompile, optimizer hotfixes

Read Committed is Bonkers - Webcast Recording (46 minutes)

If you haven’t thought much about isolation levels in SQL Server, chances are your application can easily return incorrect data to your users.

Try the course quiz anytime.

Read Committed Snapshot and Snapshot Isolation (46 minutes)

This course is an overview of why Read Committed Snapshot Isolation (RCSI) and Snapshot Isolation levels are critical for scaling workloads in SQL Server.

Try the course quiz anytime.

Repeatable Read and Serializable Isolation Levels (45 minutes)

Serializable and Repeatable Read isolation levels offer protections so your users won’t see weird or incorrect data – but there are tradeoffs for those protections.

Try the course quiz anytime.

Snapshot Isolation Against Availability Group Secondaries (28 minutes)

In just half an hour, you’ll see how queries against a readable secondary in an Availability Group are automatically escalated to Snapshot Isolation – whether you ask for it or not!

Try the course quiz anytime.

Speed Up the Popular Names Query SQLChallenge (46 minutes)

You’ve got a query that is just too slow!

SQL Server Management Studio Shortcuts and Secrets (1 hour 30 minutes)

SQL Server Management Studio has a very complex interface. Learn tricks to make using SSMS more fun and efficient.

Try the course quiz anytime.

The Case of the Slow Temp Table: A Performance Tuning Problem (50 minutes)

Why would using a temp table cause a stored procedure to slow down dramatically and use massively more logical reads, compared to a permanent table?

The Dirty Secrets of NOLOCK (50 minutes)

What happens when you use NOLOCK hints in your code, or set your isolation level to READ UNCOMMITTED in SQL Server?

Try the course quiz anytime.

The Idempotent TSQL SQLChallenge (28 minutes)

When writing TSQL, it’s often useful to make your TSQL idempotent – a fancy word, which in the case of databases really just means: you can run the command again and again and it will make sure that you have the intended effect, without causing problems by being run more than once.

Troubleshooting Blocking and Deadlocks for Beginners (2 hours 10 minutes)

Your SQL Server is slow, and you suspect blocking.

Try the course quizzes anytime: blocking diagnosis, troubleshooting retroactively, deadlocks

TSQL for Beginners (Redgate University)

This free course introduces you to the Transact SQL language implemented in SQL Server and takes you from newbie to a master of SELECT statements.

Tune the Peak Years Procedure - SQLChallenge (52 minutes)

Ready to tune some TSQL? In this challenge, you’re given a database to restore. You’ll create two indexes and a constraint in the database– and you aren’t allowed to change those.

Tuning a Stored Procedure - SQLChallenge (1 hour 10 minutes)

Your challenge is to identify which statement is slowing down our stored procedure the most, then tune the code to speed it up.

Who Made That Schema Change? A DDL Trigger SQLChallenge (28 minutes)

In this challenge, you get to take a crack at writing a DDL Trigger to track schema changes.

Who Made That Schema Change? An Event Notification SQLChallenge (27 minutes)

In this challenge, you get to take a crack at creating an Event Notification to track schema changes.

Why Creating an Index Can Slow Down a Query (1 hour 30 minutes)

Sometimes performance can go badly wrong if SQL Server has an imperfect index for an query.

Try the course quiz anytime.

Why Table Partitioning Does Not Speed Up Query Performance - With One Exception (52 minutes)

Learn why SQL Server’s table partitioning feature won’t make your queries against disk-based rowstore indexes faster– and may even make them slower.

Try the course quiz anytime.

XEvents SQLChallenge: Create an Extended Events Trace (55 minutes)

Build your skills with Extended events in this SQLChallenge.