Day Three with SQL: Inserting Data, Querying Smarter, and Working with Real Datasets
Day three was all about reinforcing the basics, not rushing forward, but getting comfortable with SQL by practicing it repeatedly on real data.
I spent most of today working through SQLZoo exercises, inserting data into PostgreSQL, and querying a realistic dataset generated with Mockaroo. This helped bridge the gap between theory and actual usage.
Inserting Data into Tables
I practiced inserting data into tables and also learned a very useful PostgreSQL feature: importing SQL files directly.
Using the psql terminal, I learned how to run SQL files with:
\i path_to_file/file_name.sql
To test this properly, I downloaded a 1,000-row dataset from Mockaroo, adjusted some table parameters and constraints to match the data, and then imported it into my database.
Seeing a large dataset populate my tables instantly made everything feel much more real.
Querying Data with SELECT (Again, but Better)
I continued practicing the now very familiar SELECT statement, but with more structure and intention.
Sorting Results with ORDER BY
I learned how to sort query results using ORDER BY.
SELECT * FROM users ORDER BY first_name;
By default, sorting is ascending (ASC), but it can be reversed using DESC.
SELECT * FROM users ORDER BY first_name DESC;
Getting Unique Values with DISTINCT
To avoid duplicate results, I practiced using DISTINCT:
SELECT DISTINCT country FROM users;
This was especially useful when working with location-based data.
Filtering with WHERE and Logical Operators
I practiced filtering results using WHERE, along with logical operators:
AND
OR
These allow conditions to be combined logically, making queries more precise.
Comparison Operators
I also learned and practiced comparison operators such as:
\= (equal)
<, > (less than, greater than)
<=, >=
<> (not equal)
These were useful for filtering ages, dates, and numeric values in the dataset.
Limiting Results with LIMIT and OFFSET
I learned how to control how many rows are returned using:
SELECT * FROM users LIMIT 10 OFFSET 20;
LIMIT controls how many rows are returned
OFFSET skips a specified number of rows
I also learned that LIMIT isn’t part of the SQL standard, which led me to discover the SQL-standard alternative.
Using FETCH Instead of LIMIT
PostgreSQL also supports the SQL-standard FETCH syntax:
SELECT * FROM users FETCH FIRST 6 ROWS ONLY;
When I saw this for the first time, I was genuinely surprised and also very grateful that LIMIT exists.
Searching with IN and BETWEEN
I practiced filtering values using sets and ranges.
Using IN
SELECT * FROM users WHERE country IN ('Nigeria', 'Ghana', 'Kenya');
Using BETWEEN
SELECT * FROM users WHERE dob BETWEEN '1990-01-01' AND '2000-12-31';
These made queries much more expressive and readable.
Pattern Matching with LIKE and ILIKE
I revisited pattern matching using:
LIKE (case-sensitive)
ILIKE (case-insensitive)
I also learned about wildcards:
% → matches any number of characters
_ → matches exactly one character
This was especially useful for querying email patterns in the Mockaroo dataset.
Grouping Results with GROUP BY
Finally, I practiced grouping records using GROUP BY.
For example, I grouped users by their countries to see how many users belonged to each location:
SELECT country_of_birth, COUNT(country_of_birth) AS "Number of Users" FROM users GROUP BY country_of_birth ORDER BY COUNT(country_of_birth);
This was my first real taste of how SQL starts to answer aggregate questions, not just retrieve rows.
Final Thoughts
Day three reinforced an important lesson: mastery comes from repetition.
Working with a real dataset made every query feel purposeful, and practicing the same concepts in different ways helped solidify my understanding. SQL is starting to feel less like syntax and more like a way of thinking.
Tomorrow, I’ll be learning and practicing even more.