DEV Community: Fidel Okumu

Subqueries & CTEs: Breaking Complex Queries into Steps

Fidel Okumu — Thu, 10 Sep 2026 13:31:31 +0000

Introduction
Some questions can't be answered with a single, flat SQL query — they require an intermediate step first. Subqueries and CTEs (Common Table Expressions) both solve this by letting one query's result feed into another, but they read and behave differently.

What Are Subqueries?
A subquery is a query nested inside another query, usually inside parentheses. It runs first, and its result is used by the outer query.

Here, the inner query (SELECT AVG(rides_completed) FROM drivers) calculates the average first. The outer query then uses that single number to filter drivers above it. What I understood here: the subquery is evaluated before the outer query can run, since the outer query depends on its result.

Subqueries can also appear in the FROM clause, acting like a temporary table:

What Are CTEs?
A CTE does the same job — precomputing an intermediate result — but is defined upfront using WITH, giving it a name that can be reused.

This produces the exact same result as the nested subquery example above, but the logic reads top-to-bottom instead of inside-out.

What I Learned
I learned that subqueries are queries placed inside another SQL query to help retrieve or filter data before the main query runs. They are useful when I need to use the result of one query to answer another question.

I also learned that CTEs (Common Table Expressions) allow me to create a temporary named result using the "WITH" keyword and then use it in another query. CTEs queries easier to read, understand and organize.

CTEs helps break down complex SQL problems into smaller and more manageable steps.

SQL Joins: Combining Data Across Tables

Fidel Okumu — Thu, 10 Sep 2026 12:34:28 +0000

Introduction
Real databases rarely keep everything in one table — driver details, ride records, and route information usually live separately to avoid duplication. Joins are how SQL brings related data back together across those tables in a single query.

What Are Joins?
A join links rows from two (or more) tables based on a shared column — usually an ID that appears in both. Without joins, I'd have to look up related information manually, one table at a time.
Types of Joins
INNER JOIN — returns only rows that match in both tables.

LEFT JOIN — returns everything from the left table, plus matches from the right; unmatched right-side rows show as NULL.

RIGHT JOIN — the mirror of LEFT JOIN: everything from the right table, plus matches from the left.

FULL OUTER JOIN — combines LEFT and RIGHT: everything from both tables, matched where possible, NULL where not.

When to Use Each

INNER JOIN — when I only care about complete, matched records (e.g., "show me fares for drivers who actually have bookings").
LEFT JOIN — when I need everything from my main table, even if some rows have no related data (e.g., "show me every driver, including those with zero bookings").
RIGHT JOIN — functionally the same as LEFT JOIN with tables swapped; I rarely use it directly, since writing a LEFT JOIN with tables in the right order is usually clearer to read.
FULL OUTER JOIN — when I need to audit for mismatches on both sides at once (e.g., finding bookings with no valid driver, and drivers with no bookings, in a single result).

What I Learned
The concept that took the most practice was realizing that a join isn't really "combining tables" in general — it's about deciding what happens to unmatched rows on each side. Once I started asking "what do I want to happen to rows without a match" for every join I wrote, choosing between INNER, LEFT, RIGHT, and FULL OUTER became a matter of answering that one question rather than memorizing four separate syntaxes.

DDL & DML: The Two Halves of SQL

Fidel Okumu — Thu, 10 Sep 2026 12:19:48 +0000

Introduction
Working with a database always splits into two separate jobs: building the structure that will hold data, and then actually putting data in, changing it, or reading it. SQL separates these two jobs into two categories of commands — DDL and DML.

What is DDL?

DDL stands for Data Definition Language. These commands define or change the structure of a database — tables, columns, and their types — without touching the actual data inside.

Example — creating a table:

Adding a column to an existing table:

What is DML?
DML stands for Data Manipulation Language. These commands work with the actual data inside the tables inserting, updating, deleting, or retrieving rows.

Example — inserting a row:

Updating a row:

Deleting a row:

Retrieving data:

Key Difference
The distinction that clarified this for me: DDL changes the container, DML changes what's inside the container. Running CREATE TABLE builds an empty structure , no data exists yet. Only after that does INSERT (a DML command) actually put rows into it.

Another important detail: most DDL commands are harder to undo. DROP TABLE deletes the table and everything in it, structure included — there's no "undo" in most database systems once it's committed. DML changes like DELETE or UPDATE are often reversible if wrapped in a transaction, but DDL is generally treated as a bigger, more permanent action.

What I Learned
Understanding that DDL commands run first, and rarely change once a table is in use, helped me realize why planning a table's structure carefully upfront (column types, primary keys) matters — going back to change it later with ALTER is possible, but riskier once real data and other queries already depend on that structure.

Python Basics: Variables, Data Types

Fidel Okumu — Wed, 09 Sep 2026 06:01:42 +0000

** Introduction**
Before writing any meaningful program, I had to understand the four building blocks of Python: variables, data types, input/output, and basic syntax. This article walks through what each of these means, how they work, and practical examples of using them.

Variables
A variable is a named container that holds a value. Instead of typing "Amina" every time I refer to a driver, I can store it once:

Once created, a variable's value can be reassigned at any point:

What I understood here is that a variable isn't the value itself , it's a label pointing to a value stored in memory. Reassigning it just moves the label to point somewhere else.

Data Types
Python automatically figures out the "type" of data a variable holds. The core types I worked with:

I can check any variable's type using the built-in type() function:

Input and Output
print() is how a Python program communicates back to the user, it's the "output".

Input() -it pauses the program and waits for the user to type something:

One important detail I learned: everything input() receives is treated as text (a string), even if the user types a number. So if I need to do math with it, I have to convert it explicitly:

What I Learned
The biggest shift in understanding was realizing that a variable's type isn't fixed by how it looks on screen , input() always hands back text, and it's my job to convert it to the right type before using it in calculations. This became a recurring theme as I moved into working with real project data, where columns coming from a database or CSV often needed the same kind of type checking before I could analyze them.

Operators and Conditionals: Making Decisions in Code

Fidel Okumu — Wed, 09 Sep 2026 05:33:00 +0000

Introduction
Once I understood variables and data types, the next question was, how does a program actually make a decision? This is where operators and conditionals come in. They let a script react differently depending on the data it's given.

Arithmetic Operators
These perform basic math:

Comparison Operators
These compare two values and always produce a True or False:

The distinction between = and == tripped me up early on : = assigns a value, == asks a question ("are these equal?"). Mixing them up is one of the most common beginner errors.

Logical Operators
These combine multiple conditions:

Conditionals: if, elif, else
Conditionals use these True/False results to decide which block of code actually runs.

Here's how I understood the flow: Python checks if first. If that's False, it moves to elif . If none of those match, it falls through to else. Only one of these blocks ever runs — never more than one, no matter how many conditions happen to be true.

What I Learned
The core insight was that conditionals aren't really about if statements — they're about restructuring a problem into a series of True/False questions. Once data can be expressed as comparisons (is this value greater than X? does it meet two conditions at once?), the program can make the same kind of decision a person would, just applied consistently across thousands of rows without manual review.

Loops: Repeating Work Without Repeating Code

Fidel Okumu — Tue, 08 Sep 2026 12:51:33 +0000

Introduction
A huge part of programming is doing the same action many times — checking every driver in a list, processing every row of data, or repeating a task until a condition is met. Loops are how Python handles this without forcing me to copypaste the same line over and over.
For Loops
A for loop runs a block of code once for every item in a collection.

What I understood here: driver is a temporary variable that takes on each value in drivers, one at a time in order. The loop runs exactly as many times as there are items in the list four times, in this case.

While Loops
A while loop repeats until a condition becomes false, rather than looping over a fixed collection.

The detail that took the most getting used to: the condition is checked before every round, and the loop starts counting from 0. So while rides_completed < 3 actually runs 3 times (for 0, 1, 2), not what I initially assumed. Forgetting the += 1 line entirely would make the condition stay true forever, causing an infinite loop — one of the most common mistakes with while loops.

Break and Continue
These give more control over a loop's execution:

The distinction: break exits the loop immediately and nothing after it runs, not even for remaining items. continue only skips the current round the loop still checks every other item normally.

Enumerate()
Sometimes I need both the item and its position in the list. Enumerate() provides both at once:

What I Learned
I learned that loops allow Python to repeat instructions automatically until a certain condition is met or until all items have been processed.

Functions: Writing Reusable Code

Fidel Okumu — Tue, 08 Sep 2026 12:22:51 +0000

Introduction
As my scripts grew longer, I noticed the same blocks of logic showing up again and again.
Functions lets a user write a piece of logic once and reuse it anywhere, with different data each time.

Defining and Calling Functions
Defining a function only saves its instructions — it doesn't run anything yet:

Calling it is what actually executes the code:

Parameters and Arguments
A parameter is the placeholder name written inside the function definition — an empty slot waiting for a value.
An argument is the real value handed over when the function is actually called.

A function can take multiple parameters

Return Values
Return sends a value back to whoever called the function, so it can be stored and reused elsewhere — unlike print(), which only displays something once.

An important detail: as soon as a function hits a return statement, it exits immediately. Any code written after return inside that function never runs

What I Learned
Functions reframed how I think about writing code — instead of asking "what should this line do," I started asking "what small reusable task does this represent?, and what inputs does it need?." Understanding parameters versus arguments, and that variables inside a function have their own separate scope

PYTHON Data Structures lists, Tuples, Dictionaries and Sets

Fidel Okumu — Tue, 08 Sep 2026 11:50:15 +0000

INTRODUCTION
After learning storing single values in variables, We needed a way to hold collection of data i.e multiple ride counts
multiple cities etc.
Python offers four main data structures for this that is:

LISTS
A list is a built-in data type used to store multiple items in a single variable.
A list can be changed and allows addition of more items
It can also contain items of different data types
Lists also preserve and allows duplicate values

![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/njfzoohpy0tokgot2si1.png

TUPLES
A tuple is similar to a list but once created, it cannot be changed.

Trying to modify a tuple raises an error by design.
Tuples are mainly used when values should stay fixed throughout a program example: routes fixed origin and destinations.

DICTIONARIES
A dictionary stores data in key-value.
This allows lookups by name instead of position
example;

Dictionaries are written in curly brackets {}
Each has a corresponding value
The keys should be unique
Dictionaries can be changed

SETS
A set stores only unique values any duplicates are automatically removed
They are written using curly brackets {}
You can add or remove items in a set
They are useful when keeping unique items

What I Learned
The most useful shift in understanding was realizing that choosing a data structure is really a design decision, not just a syntax choice. Picking a list when a dictionary is more appropriate (or vice versa) doesn't just look sloppy — it makes later code longer and harder to reason about. Matching the structure to what the data actually needs to do made every function I wrote afterward noticeably simpler.