TypeVelo.
← Drills Hub

SQL Typing Drill

SELECT FROM WHERE * = , ( ) '

Every passage contains: * = , ( ) ' · SELECT FROM WHERE

Net 0 wpmGross 0 wpmAcc 100%
DELETE FROM rows WHERE count = 0; SELECT COUNT(*) FROM rows WHERE name = 'open'; SELECT COUNT(*) FROM rows WHERE name = 'open'; SELECT COUNT(*) FROM rows WHERE name = 'open'; DELETE FROM rows WHERE count = 0; SELECT COUNT(*) FROM rows WHERE name = 'open'; SELECT name, count FROM rows WHERE active = 1; SELECT * FROM rows; SELECT COUNT(*) FROM rows WHERE name = 'open'; SELECT r.name FROM rows r JOIN tags t ON t.id = r.tag_id; SELECT tag, SUM(count) FROM rows GROUP BY tag; SELECT * FROM rows; SELECT name FROM rows ORDER BY count DESC LIMIT 10; SELECT name, count FROM rows WHERE active = 1; SELECT tag, SUM(count) FROM rows GROUP BY tag; CREATE INDEX idx_rows_name ON rows (name); SELECT name FROM rows ORDER BY count DESC LIMIT 10; DELETE FROM rows WHERE count = 0; SELECT r.name FROM rows r JOIN tags t ON t.id = r.tag_id; SELECT name FROM rows ORDER BY count DESC LIMIT 10; INSERT INTO rows (name, count) VALUES ('first', 1); SELECT * FROM rows; CREATE INDEX idx_rows_name ON rows (name); DELETE FROM rows WHERE count = 0; SELECT r.name FROM rows r JOIN tags t ON t.id = r.tag_id; DELETE FROM rows WHERE count = 0; SELECT * FROM rows; SELECT r.name FROM rows r JOIN tags t ON t.id = r.tag_id; SELECT name, count FROM rows WHERE active = 1; CREATE INDEX idx_rows_name ON rows (name); SELECT COUNT(*) FROM rows WHERE name = 'open'; SELECT * FROM rows; SELECT name, count FROM rows WHERE active = 1; SELECT * FROM rows; DELETE FROM rows WHERE count = 0; CREATE INDEX idx_rows_name ON rows (name); SELECT tag, SUM(count) FROM rows GROUP BY tag; SELECT * FROM rows; SELECT name, count FROM rows WHERE active = 1; SELECT * FROM rows;

QWERTY layout assumed. Backspace corrects; uncorrected errors count against net WPM.

SELECT * FROM rows; is twenty characters long and asks for four separate shift changes. Shift engages and holds through all six letters of SELECT, releases at the space, engages again for a single tap on the asterisk, releases, engages a third time and holds through FROM's four letters, then releases for good — rows and the closing semicolon need no modifier at all. That's a shift pattern none of this batch's other languages ask for: held across a whole word rather than tapped once for a single capital letter, several times inside one short line.

This drill's required character set — asterisk, equals sign, comma, parentheses and a single quote — is the smallest in the whole batch, just six characters. What makes SQL demanding isn't a wide symbol set at all; it's that its keywords are conventionally written in capitals, so Shift has to stay down through an entire word instead of being tapped for one letter and released.

SELECT COUNT(*) FROM rows WHERE name = 'open'; ends with something the line's opening didn't have at all: a value inside single quotes, needing no Shift whatsoever. The same line that just demanded six letters of held-down Shift for SELECT asks for none once the actual data starts. The Code Typing Test is a fair place to see whether that shift discipline holds up once SQL is mixed in among other languages rather than practised alone.

Why This Drill

A keyword's capitals aren't decoration — SELECT written in lowercase still runs in most databases, but the convention exists so a reader can tell keyword from identifier at a glance, and getting that discipline into the hands means holding Shift across a full word rather than tapping it the way the Capitalization Timing Drill trains for an ordinary sentence, where a capital only ever needs one shift press for the first letter.

ORDER BY and GROUP BY raise a question ordinary capitalized prose never does: since the space bar produces the same keystroke whether Shift is held or not, a typist could keep Shift down continuously across the gap between the two words, or release it and press it again at the boundary — both produce identical, correct text, which is a choice no single capitalized word ever presents.

The single-quoted value at the end of a line is where all of that shift discipline stops at once. name = 'open' needs no modifier anywhere in it, right after a keyword that demanded six letters of held Shift a few characters earlier — a full reset the Quotation Mark Drill's own examples don't have to contend with, since that drill's marks aren't sitting beside sustained capitals in the first place.

Shift Held Across a Whole Word, Not Tapped for One Letter

SELECT, FROM, WHERE and DELETE each need Shift held down through every one of their letters, then released at the space that follows. That's a different discipline from an ordinary capitalized word, which only ever needs a single shift press for its first letter before releasing for the rest.

Four Shift Changes in One Short Line

SELECT * FROM rows; toggles Shift four separate times — held for SELECT, tapped once for the asterisk, held again for FROM, then off entirely for rows and the closing semicolon. No other line this short in this batch's eight drills asks for that many distinct shift states.

A Word Boundary Shift Doesn't Have to Cross

Because the space bar doesn't respond to Shift one way or the other, ORDER BY and GROUP BY could be typed with Shift held continuously from the first letter through to the last, gap and all, or released and reacquired at the space — a choice that simply doesn't arise for a single capitalized word.

Where the Shift Discipline Suddenly Stops

name = 'open' needs no Shift at all — not for the equals sign, not for the quote marks, not for the lowercase value between them — immediately after a keyword that demanded sustained Shift for six full letters. The contrast inside one line is sharper here than in any other drill in this batch.

Frequently Asked Questions

Why is SQL the only language in this batch conventionally typed in capitals?

It's a long-standing convention for telling keywords apart from table and column names at a glance, and this drill trains the specific shift discipline that convention requires — held across a whole word rather than tapped for one letter.

Do I need to release Shift between the two words in ORDER BY?

Not necessarily — since the space bar produces the same character whether Shift is held or not, keeping Shift down continuously across the gap works just as well as releasing and reacquiring it at the space.

Why does the value inside 'open' need no Shift at all, right after a capitalized keyword?

Single-quoted string values in SQL are written in whatever case they actually are, and the apostrophe key itself needs no modifier on a US layout, so a line can go from sustained Shift to none at all within a handful of characters.

How is this different from the Capitalization Timing Drill?

That drill capitalizes the first letter of ordinary sentence words, which only ever needs one shift tap per word. This drill holds Shift across entire multi-letter keywords, a sustained rather than tapped use of the same key.

Why does this drill have the smallest required character set of the whole batch?

SQL's own syntax uses relatively few distinct symbols — an asterisk, an equals sign, a comma, parentheses and a quote mark cover nearly everything this passage needs, fewer even than the seven characters the Go Typing Drill needs, which is the next smallest set in this batch.

Does SQL actually have to be written in capitals, or is that just a habit?

Most databases run a lowercase SELECT exactly the same as an uppercase one — it's a convention rather than a requirement, but it's close to universal in real code, which is why this drill treats it as the default.