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.