Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve for…

Read more

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve for…

Read more

Can you believe it’s already been 2 months since (from ) and I (from ) kicked off our SQL Crash Course? 🎉
What started as a fun idea quickly turned into a full-blown series — and today, we’re sharing a recap of everything we’ve covered… and what’s coming next! 🙌🏻

🔥 What’s inside the course?

We’ve structured the course into 7 key modules to take you from zero to SQL hero:

1. Introduction – What SQL is and why it matters

2. SQL Fundamentals – Basic commands, filtering, and aggregation

3. Intermediate SQL – Joins, unions, and functions

4. Advanced SQL – Subqueries, CTEs, recursion, and views

5. Database Operations – CRUD, schema changes, and optimization

6. Crafting Good SQL Queries – Best practices for writing efficient queries

7. Real-world Problems – Applying SQL to practical challenges

✅ What We’ve Covered So Far

We’ve completed Modules 1 through 6 — all the theory and best practices you need.
You can catch up on each lesson here:

1️⃣ Introduction to SQL

• #1. What is SQL? → link

• #2. Why Learn SQL? → link

• #3. Relational Data & Models → link

2️⃣ SQL Fundamentals

• #4. Basic Commands (SELECT, FROM, WHERE) → link

• #5. Sorting & Limiting (ORDER BY, LIMIT)→ link

• #6. Aggregate Functions (SUM, AVG, COUNT, etc.) → link

3️⃣ Intermediate SQL

• #7. JOINS (INNER, LEFT, RIGHT, FULL) → link

• #8. UNION & UNION ALL → link

• #9. Case Expressions → link

• #10. Functions (String, Date, Numeric) → link

4️⃣ Advanced SQL

• #11. Subqueries → link

• #12. Common Table Expressions (CTEs) → link

• #13. Recursion → link

• #14. Views → link

5️⃣ Database Operations

• #15. CRUD operations (INSERT, UPDATE, DELETE) → link

• #16. Database modifications (ALTER, DROP, CREATE) → link

• #17. Indexing & Optimization → link

6️⃣ Crafting Good SQL queries

• #18. Modular Code →link

• #19. SQL Execution Order → link

• #20. Query Optimization → link

So the following question is…

🔜 What’s Next?

Now it’s time to put theory into practice! Over the next few weeks, we’ll release hands-on exercises and projects to help you apply what you’ve learned:

7️⃣ 7. Real-World Problems (Quick Wins)

Easy-level problems, perfect for 30–60 minutes of practice:

• Problem 1 → 29th May

• Problem 2→ 29th May

• Problem 3 → 5th June

• Problem 4→ 5th June

🧪 Mini-Projects (Deeper Dives)

Medium-difficulty projects to consolidate your skills:

• Mini-Project 1 → 19th June

• Mini-Project 2 → 19th June

💣 Final Projects (End-to-End Challenges)

Advanced, real-life projects released in multiple parts:

• Project 1 → 26th June (with multiple issues in the following weeks)

• Project 2 → 26th June (with multiple issues in the following weeks)

We’ll share full project briefs and walkthroughs — so stay tuned!

💡 Where to Follow Along?

We’ll continue posting weekly updates in our newsletters:

• DataBites (by Josep)

• Non-Brand Data (by Cornellius)

👉 Check out the GitHub repo and stay tuned for the first post!

Let’s dive in and make SQL less scary, more fun, and way more useful! 🚀

Josep & Cornellius

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve for…

Read more

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve for…

Read more

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve for…

Read more

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve for…

Read more

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve forgotten what we’ll cover, we will examine seven key SQL topics, each divided into multiple posts across Non-Brand Data and DataBites.

📚 Previously in SQL Basics…

Remember last Thursday we already saw:

📌 #9 – Case Expressions
📌 #10 – Functions (String, Date, Numeric)

Today, we will explore an exciting new topic in our SQL learning:

Advanced SQL🤩

In today’s topic, we have two new brand issues:

📌 #11 – Subqueries: in will walk you through the subquery concept.

📌 #12 - Common Table Expressions (CTEs): The article you are reading right now, where you will grasp CTEs and what they are used for.

So don’t miss out—let’s keep the SQL momentum going!

Subscribe now

🧱 What are Common Table Expressions (CTEs)?

CTEs are named temporary result sets you define at the beginning of your SQL query using the WITH clause.

You can reference them multiple times within the same query, making your SQL modular, clean, and easy to read.

Think of CTEs as building blocks that let you break down complex queries into logical, bite-sized steps.

CTEs often follow this structure:

WITH 

cte_name AS (
  SELECT ...
  FROM ...
  WHERE ...
)
SELECT ...
FROM cte_name
WHERE ...;

You can even chain multiple CTEs together:

WITH 
cte1 AS (
...
),

cte2 AS (
SELECT ...
FROM cte1
WHERE ...
)

SELECT ...
FROM cte2;

✅ When to Use CTEs:

👉🏻 When you want to modularize your logic for clarity
👉🏻 When you need to reuse intermediate steps in your query
👉🏻 When working with nested aggregations or multi-step filters
👉🏻 When debugging or collaborating with others

Let’s see CTEs in action!👇🏻

#1. Modular Metric Calculation

🧩 Real-world scenario:
"Compute department-level revenue and rank them by performance."

Without CTEs, everything is packed into one long query:

SELECT 
  n.name, 
  SUM(i.points) AS total_points
FROM newsletters n
JOIN posts p ON n.id = p.newsletter_id
JOIN interactions i ON p.id = i.post_id
GROUP BY n.name
ORDER BY total_points DESC;

With CTEs, we separate concerns:

WITH newsletter_points AS (
  SELECT 
    n.id AS newsletter_id,
    SUM(i.points) AS total_points
  FROM newsletters n
  JOIN posts p ON n.id = p.newsletter_id
  JOIN interactions i ON p.id = i.post_id
  GROUP BY n.id
)
SELECT n.name, np.total_points
FROM newsletter_points np
JOIN newsletters n ON n.id = np.newsletter_id
ORDER BY np.total_points DESC;

🧠 Why CTE: Improves readability, keeps each logical unit isolated, and allows reuse for dashboards or additional transformations.

#2. Reusable Intermediate Filters

🧩 Real-world scenario:
"List top-performing employees only from high-revenue departments."

With multiple subqueries, this can quickly get messy.
CTEs make it clear and structured:

WITH high_engagement_newsletters AS (
  SELECT 
    n.id AS newsletter_id
  FROM newsletters n
  JOIN posts p ON n.id = p.newsletter_id
  JOIN interactions i ON p.id = i.post_id
  GROUP BY n.id
  HAVING SUM(i.points) > 10
),
top_posts AS (
  SELECT 
    p.id, 
    p.name, 
    SUM(i.points) AS total_post_points
  FROM posts p
  JOIN interactions i ON p.id = i.post_id
  GROUP BY p.id, p.name
)
SELECT tp.name, tp.total_post_points
FROM top_posts tp
JOIN posts p ON tp.id = p.id
WHERE p.newsletter_id IN (
  SELECT newsletter_id FROM high_engagement_newsletters
);

🧠 Why CTE: Makes filtering logic modular and self-explanatory. Separates what qualifies a newsletter from what makes a post significant.

#3. Step-by-Step Aggregation

🧩 Real-world scenario:
"Find the average performance per region after normalizing by team size."

Instead of deeply nested subqueries, use layered CTEs:

WITH post_points AS (
  SELECT 
    p.id AS post_id, 
    p.newsletter_id, 
    SUM(i.points) AS total_points
  FROM posts p
  JOIN interactions i ON p.id = i.post_id
  GROUP BY p.id, p.newsletter_id
),
normalized_post_points AS (
  SELECT 
    pp.post_id,
    pp.newsletter_id,
    pp.total_points / COUNT(i.id) AS normalized_score
  FROM post_points pp
  JOIN interactions i ON pp.post_id = i.post_id
  GROUP BY pp.post_id, pp.newsletter_id, pp.total_points
),
newsletter_avg_score AS (
  SELECT 
    n.id AS newsletter_id,
    AVG(npp.normalized_score) AS avg_normalized_score
  FROM newsletters n
  JOIN normalized_post_points npp ON n.id = npp.newsletter_id
  GROUP BY n.id
)
SELECT n.name, nas.avg_normalized_score
FROM newsletter_avg_score nas
JOIN newsletters n ON nas.newsletter_id = n.id;

🧠 Why CTE: Breaks down multi-step logic into focused blocks

—total points → normalized per post → average per newsletter.

Super maintainable and easy to expand later.

🎯 Summary: Why You Should Love CTEs

CTEs = Clean, Transparent, and Reusable SQL.

🔹 Modularity: Break logic into logical units
🔹 Reusability: Reference CTEs across the same query
🔹 Readability: Easier to understand than nested subqueries
🔹 Maintainability: Simplifies debugging and collaboration

💡 Pro Tip: CTE vs Subquery

While subqueries are great for quick logic, prefer CTEs when:

✅ You have multiple steps
✅ You want to reuse intermediate results
✅ You need collaboration-ready SQL
✅ You’re debugging a complex transformation

👉🏻 SQL playground with all CTEs expressions examples

How to Get Started 🚀

Over the coming weeks, we’ll guide you through:

✅ SQL Fundamentals
✅ Intermediate SQL
✅ Advanced SQL
✅ Database Operations
✅ Writing Efficient Queries

Once you grasp the basics, practice is key! Start working on real-world projects and solving hands-on data problems.

What’s Next? ➡️

This is the first of many posts about the upcoming SQL Courses. It will only explain what SQL is in its crude form.

To get the full experience and fully immersed in the learning:

👉 Subscribe to Databites.tech (By Josep)

👉 Subscribe to Non-Brand Data (By Cornellius)

👉 Check out the SQL Crash Course GitHub repo

👉 Share with your friend and whoever needs it!

Let’s dive in and make SQL less scary, more fun, and way more useful! 🚀

Josep & Cornellius

🎉 DataBites just hit 8,000 subs & #76 in Rising Tech on Substack — thanks to you!
To celebrate, get 20% off for life on the paid plan until April 13.
👉🏻 Grab it here if you want full access to guides, cheatsheets, and more.

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve forgotten what we’ll cover, we will examine seven key SQL topics, each divided into multiple posts across Non-Brand Data and DataBites.

📚 Previously in SQL Basics…

Remember last Thursday we already saw

📌 #7 – JOINS (INNER, LEFT, RIGHT, FULL) by me in
📌 #8 – UNION & UNION ALL by in .

Today, two fresh issues just dropped:

📌 #9 – Case Expressions – the one you're reading right now is all about combining understanding CASE expressions in SQL.
📌 #10 – Functions (String, Date, Numeric) – where Cornellius explains how to work with SQL functions.

So don’t miss out—let’s keep the SQL momentum going!

Subscribe now

🎯 Why CASE expressions matter

Sometimes you want your query to behave differently depending on values in your data — like showing “High”, “Medium”, or “Low” based on a score or defining a concrete category according to a numerical value.

Instead of running multiple queries or post-processing in Python or Excel…
you can do it right in SQL using a CASE expression.

🧱 What is a CASE expression?

Think of it as an IF / ELSE IF / ELSE block in SQL.

You check conditions one by one, and return a value when the first match is found.

It works inside SELECT, WHERE, ORDER BY, even GROUP BY.

The most common structure:

SELECT 
  CASE 
    WHEN condition1 THEN result1
    WHEN condition2 THEN result2
    ELSE default_result
  END AS alias
FROM your_table;

• CASE: Begins the conditional logic block.

• WHEN condition THEN result: If condition is TRUE, return result.

• Multiple WHEN clauses: You can include as many WHEN clauses as needed, each testing a different condition.

• ELSE default_result: Returned if no WHEN conditions are true.

• END: Closes the CASE block.

• AS alias: Names the resulting column.

🔍 Example 1 – Categorizing Interaction Volume

Let’s use our POSTS and INTERACTIONS tables.

We’ll count how many interactions each post received and categorize them:

SELECT 
    P.name AS post_name,
    COUNT(I.id) AS num_interactions,
    CASE 
        WHEN COUNT(I.id) = 0 THEN '🟥 No Interactions'
        WHEN COUNT(I.id) BETWEEN 1 AND 3 THEN '🟨 Low'
        WHEN COUNT(I.id) BETWEEN 4 AND 6 THEN '🟧 Medium'
        ELSE '🟩 High'
    END AS interaction_level
FROM POSTS P
LEFT JOIN INTERACTIONS I
    ON P.id = I.post_id
GROUP BY P.name;

🧠 This is great for building dashboards or summaries that are easier to understand at a glance.

🔍 Example 2 – Conditional Filtering in WHERE

Want to only show interactions that are likes or comments, and group all other types as “Other”? Use CASE in a WHERE clause:

SELECT 
    I.id,
    I.type_of_interaction,
    CASE 
        WHEN I.type_of_interaction = 'like' THEN 'Like'
        WHEN I.type_of_interaction = 'comment' THEN 'Comment'
        ELSE 'Other'
    END AS interaction_category
FROM INTERACTIONS I;

🧠 This helps you simplify messy or inconsistent data directly in your query logic.

🔄 Bonus: CASE in ORDER BY

You can also use CASE to custom sort results. For example, prioritize posts with no interactions:

SELECT 
    P.name,
    COUNT(I.id) AS num_interactions
FROM POSTS P
LEFT JOIN INTERACTIONS I
    ON P.id = I.post_id
GROUP BY P.name
ORDER BY 
  CASE 
    WHEN COUNT(I.id) = 0 THEN 0
    ELSE 1
  END,
  P.name;

🧠 Super helpful when you want certain categories to float to the top — without changing your database.

✅ Summary: Use CASE When You Want To…

• Add custom labels or categorical buckets to your query output

• Transform values based on conditions

• Simulate IF/ELSE logic directly in SQL

• Clean or normalize data on the fly

• Control sorting, filtering, and grouping dynamically

👉🏻 SQL playground with all CASE expressions examples

How to Get Started 🚀

Over the coming weeks, we’ll guide you through:

✅ SQL Fundamentals
✅ Intermediate SQL
✅ Advanced SQL
✅ Database Operations
✅ Writing Efficient Queries

Once you grasp the basics, practice is key! Start working on real-world projects and solving hands-on data problems.

What’s Next? ➡️

This is the first of many posts about the upcoming SQL Courses. It will only explain what SQL is in its crude form.

To get the full experience and fully immersed in the learning:

👉 Subscribe to Databites.tech (By Josep)

👉 Subscribe to Non-Brand Data (By Cornellius)

👉 Check out the SQL Crash Course GitHub repo

👉 Share with your friend and whoever needs it!

Let’s dive in and make SQL less scary, more fun, and way more useful! 🚀

Josep & Cornellius

🎉 DataBites just hit 8,000 subs & #76 in Rising Tech on Substack — thanks to you!
To celebrate, get 20% off for life on the paid plan until April 13.
👉🏻 Grab it here if you want full access to guides, cheatsheets, and more.

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve forgotten what we’ll cover, we will examine seven key SQL topics, each divided into multiple posts across Non-Brand Data and DataBites.

📚 Previously in SQL Basics…

Remember last Thursday we already saw

📌 #5 Filtering and Sorting by me in DataBites
📌 #6 Aggregate Functions by Cornellius Yudha Wijaya in Non-Brand Data.

Today, two fresh issues just dropped:

📌 #7 – JOINS (INNER, LEFT, RIGHT, FULL) – the one you're reading right now, all about combining tables to unlock richer insights
📌 #8 – UNION & UNION ALL – where Cornellius explains how to stack query results efficiently

This marks the beginning of a four-part Intermediate SQL journey:

1. JOINS (INNER, LEFT, RIGHT, FULL)

2. UNION & UNION ALL

3. CASE Expressions

4. Functions (String, Date, Numeric)

So don’t miss out—let’s keep the SQL momentum going!

Subscribe now

🔗 SQL JOINS – Unlocking Relationships Between Tables

In relational databases, data often lives across multiple tables. JOINS are the bridge that connects these tables, allowing us to extract insights that would otherwise remain hidden.

But let’s be honest — JOINS can be confusing at first.

Which one should you use? What happens to unmatched rows?

No worries — we’ve got your back. We’ll break it down using:

• Two generic tables (TableA, TableB) for structure

• Real examples using three concrete tables: POSTS, INTERACTIONS, and NEWSLETTERS

There are seven main types of JOIN we can perform using SQL.

Subscribe now

Now let’s break them down 👇🏻

✅ LEFT JOIN

🔹 What it does:
Returns all records from TableA (left table) and the matching records from TableB (right table). If no match exists, you still get the row from A with NULL values from B.

🔹 Use case:
List all posts — even those that received no interaction.

Structure:

SELECT *  
FROM A  
LEFT JOIN B  
ON A.KEY = B.KEY  

Real Example:

SELECT 
    P.name AS post_name, 
    I.type_of_interaction 
FROM POSTS P 
LEFT JOIN INTERACTIONS I 
  ON P.id = I.post_id;

🧠 Posts with no interactions will still appear — with NULLs for the interaction fields.

Subscribe now

✅ RIGHT JOIN

🔹 What it does:
Returns all records from TableB, and any matching rows from TableA. If there’s no match, A’s fields will be NULL.

🔹 Use case:
Show all interactions, even if the referenced post is missing.

Structure:

SELECT *  
FROM A  
RIGHT JOIN B  
   ON A.KEY = B.KEY  

Example with our newsletter’s data:

SELECT 
    I.id AS interaction_id,
    P.name AS post_name,
    I.type_of_interaction
FROM POSTS P
RIGHT JOIN INTERACTIONS I
    ON P.id = I.post_id;

🧠 Helpful for identifying orphaned interactions — though in this dataset, all are valid.

Subscribe now

✅ LEFT JOIN (Without Overlapping)

🔹 What it does:
Returns rows from A that don’t have a match in B.

🔹 Use case:
Find posts that have received no interactions.

Structure:

SELECT *  
FROM A  
LEFT JOIN B  
  ON A.KEY = B.KEY  
WHERE B.KEY IS NULL  

Example with our newsletter’s data:

SELECT 
    P.name
FROM POSTS P
LEFT JOIN INTERACTIONS I
    ON P.id = I.post_id
WHERE I.id IS NULL;

🧠 Great to identify content that might need promotion or a second look.

Subscribe now

✅ RIGHT JOIN (Without Overlapping)

🔹 What it does:
Returns rows from B that don’t match anything in A.

🔹 Use case:
Spot inconsistent data — e.g., interactions without matching posts.

Structure:

SELECT *  
FROM A  
RIGHT JOIN B  
  ON A.KEY = B.KEY  
WHERE A.KEY IS NULL  

Example with our newsletter’s data:

SELECT 
    I.id,
    I.post_id
FROM POSTS P
RIGHT JOIN INTERACTIONS I
    ON P.id = I.post_id
WHERE P.id IS NULL;

🧠 Useful for quality assurance — even if the current data has no such issues.

Subscribe now

✅ FULL OUTER JOIN (Simulated via UNION)

🔹 What it does:
Returns all records from both tables, matching where possible. Rows with no match in either table will have NULLs on one side.

🔹 Use case:
Get a complete overview of all posts and interactions.

Structure:

SELECT *  
FROM A  
FULL OUTER JOIN B  
  ON A.KEY = B.KEY  

Query Example: Combines all rows from both tables — matching where possible, keeping everything else.

SELECT 
    P.name AS post_name,
    I.type_of_interaction
FROM POSTS P
OUTER JOIN INTERACTIONS I
    ON P.id = I.post_id

🧠 You’ll get everything — connected or not.

🔹 Important for MySQL users:
❗ MySQL does not support FULL OUTER JOIN directly. To achieve this behavior, you'll need to combine a LEFT JOIN and a RIGHT JOIN using UNION.

-- Simulated FULL OUTER JOIN in MySQL using UNION
SELECT 
    P.name AS post_name,
    I.type_of_interaction
FROM posts P
LEFT JOIN interactions I
    ON P.id = I.post_id

UNION

SELECT 
    P.name AS post_name,
    I.type_of_interaction
FROM posts P
RIGHT JOIN interactions I
    ON P.id = I.post_id;

Subscribe now

✅ FULL JOIN (Without Overlapping)

🔹 What it does:
Shows only the non-matching records from both tables — highlighting differences.

🔹 Use case:
Identify discrepancies between two datasets.

Structure:

SELECT *  
FROM A  
FULL OUTER JOIN B  
  ON A.KEY = B.KEY  
WHERE A.KEY IS NULL OR B.KEY IS NULL  

Query Example:

SELECT
    A.A_KEY,
    A.A_NAME,
    B.B_KEY,
    B.DEPARTMENT
FROM TableA A
FULL OUTER JOIN TableB B
    ON A.A_KEY = B.B_KEY
WHERE A.A_KEY IS NULL
   OR B.B_KEY IS NULL;

🧠 This query isolates what’s not connected — a powerful tool for data validation.

❗ FULL OUTER JOIN is not available in MySQL, so you'll need to simulate this logic using a UNION between a LEFT JOIN ... WHERE IS NULL and a RIGHT JOIN ... WHERE IS NULL.

-- Simulated FULL OUTER JOIN (no match only) in MySQL using UNION
SELECT 
    P.name AS post_name,
    I.type_of_interaction
FROM posts P
LEFT JOIN interactions I
    ON P.id = I.post_id
WHERE I.post_id IS NULL

UNION

SELECT 
    P.name AS post_name,
    I.type_of_interaction
FROM posts P
RIGHT JOIN interactions I
    ON P.id = I.post_id
WHERE P.id IS NULL;

Subscribe now

✅ INNER JOIN

🔹 What it does:
Returns only matching rows from both tables.

🔹 Use case:
See which posts have at least one interaction.

Structure:

SELECT *  
FROM A  
INNER JOIN B  
  ON A.KEY = B.KEY  

Real Example:

SELECT 
    P.name AS post_name, 
    I.type_of_interaction 
FROM POSTS P 
INNER JOIN INTERACTIONS I 
   ON P.id = I.post_id;

🧠 Great when you’re only interested in records that exist in both tables.

Subscribe now

💡 BONUS: Joining 3 Tables

🔹 What it does:
Connects NEWSLETTERS, POSTS, and INTERACTIONS for full context.

🔹 Use case:
List the newsletter name, post title, and interaction type — all in one view.

SELECT 
    N.name AS newsletter_name,
    P.name AS post_title,
    I.type_of_interaction
FROM NEWSLETTERS N
JOIN POSTS P
    ON N.id = P.newsletter_id
JOIN INTERACTIONS I
    ON P.id = I.post_id;

🧠 This is how you create powerful multi-table reports and dashboards.

Subscribe now

🧠 Summary Table – How to Read JOIN Results

• LEFT JOIN → All from left table + matches from right

• RIGHT JOIN → All from right table + matches from left

• LEFT JOIN (no match) → Rows from left with no match in right

• RIGHT JOIN (no match) → Rows from right with no match in left

• FULL OUTER JOIN (via UNION) → All records from both tables, matched or not

• FULL JOIN (no match) → Only non-matching records from both tables

• INNER JOIN → Only matching records from both tables

And now? It is your turn to play in our SQL playground with these two clauses.

👉🏻 SQL playground with all the different types of JOINs

How to Get Started 🚀

Over the coming weeks, we’ll guide you through:

✅ SQL Fundamentals
✅ Intermediate SQL
✅ Advanced SQL
✅ Database Operations
✅ Writing Efficient Queries

Once you grasp the basics, practice is key! Start working on real-world projects and solving hands-on data problems.

What’s Next? ➡️

This is the first of many posts about the upcoming SQL Courses. It will only explain what SQL is in its crude form.

To get the full experience and fully immersed in the learning:

👉 Subscribe to Databites.tech (By Josep)

👉 Subscribe to Non-Brand Data (By Cornellius)

👉 Check out the SQL Crash Course GitHub repo

👉 Share with your friend and whoever needs it!

Let’s dive in and make SQL less scary, more fun, and way more useful! 🚀

Josep & Cornellius

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve forgotten what we’ll cover, we will examine seven key SQL topics, each divided into multiple posts across Non-Brand Data and DataBites.

📚 Previously in SQL Basics…

Remember last Thursday we already saw

📌 #3 Relational Data & Models by me in DataBites

📌 #4 Basic Commands by Cornellius Yudha Wijaya in Non-Brand Data.

Today, two fresh issues just dropped:

📌 #5 Filtering and Sorting (the one you're reading now) – where we focus on two essential commands: ORDER BY and LIMIT
📌 #6 Aggregate Functions – in which Cornellius walks you through the most commonly used aggregates like SUM, AVG, and COUNT

With these, we wrap up Section 2: SQL Basics 🎉
Next week, we jump into Intermediate SQL with four exciting topics:

• JOINS (INNER, LEFT, RIGHT, FULL)

• UNION & UNION ALL

• CASE Expressions

• Functions (String, Date, Numeric)

So don’t miss out—let’s keep the SQL momentum going!

Subscribe now

SQL Filtering & Sorting 🧹📊

Previously, we explored the SELECT, FROM, and WHERE commands — the building blocks of SQL.
Now, it’s time to take things up a notch.

Once you’ve filtered your data using WHERE, what if you want to sort the results? Or limit how many rows are returned?

That’s where ORDER BY and LIMIT come in.

These commands let you organize and control your query results. You’ll learn how to:

📌 ORDER BY to sort your data (ascending/descending).
📌 LIMIT to return only a specific number of rows.

Combine them for cleaner, faster results.

Let’s dive in.

Subscribe now

✅ ORDER BY Command

The ORDER BY clause answers the question: “How should I sort the results?”

What It Does

Sorts the result set by one or more columns.
Defaults to ascending order (ASC), but you can use descending (DESC) too.

SELECT column1, column2  
FROM table_name  
ORDER BY column1 [ASC|DESC];

Let’s see various examples for the SELECT command:

👉 Sort Products by Price (Low to High)

SELECT product_name, price  
FROM products  
ORDER BY price ASC;

👉 Sort Products by Price (High to Low)

SELECT product_name, price  
FROM products  
ORDER BY price DESC;

👉 Sort by Multiple Columns

SELECT product_name, category, price  
FROM products  
ORDER BY category ASC, price DESC;

The Syntax for ORDER BY is always in the later part of our queries, as this command signifies that we want to order our final output in a specific way.

Subscribe now

✅ LIMIT Command

The LIMIT clause answers: “How many results do I want to see?”

What It Does

Restricts the number of rows returned by your query.
Very useful when previewing data or working with large datasets. Its main advantages are two:

• To control the number of data processed when running a quick query.

• To set a maximum number of output records that the system can return.

The Syntax is present as follows:

SELECT column1  
FROM table_name  
LIMIT number;

Let’s see various examples for the SELECT command:

👉 Get the First 10 Products

SELECT product_name  
FROM products  
LIMIT 10;

👉 Top 5 Most Expensive Products

SELECT product_name, price  
FROM products  
ORDER BY price DESC  
LIMIT 5;

👉 Combine WHERE, ORDER BY, and LIMIT

SELECT product_name, price  
FROM products  
WHERE category = 'Electronics'  
ORDER BY price DESC  
LIMIT 3;

The LIMIT clause always goes in the end as it limits the number of records that the output can return.

And now? It is your turn to play in our SQL playground with these two clauses.

👉🏻 SQL playground with ORDER BY and LIMIT

Subscribe now

And there you have it — your toolkit to filter, sort, and focus your queries.
These two commands might look simple, but they make your SQL results way more useful.

Stay tuned as we move deeper into SQL! 👩‍💻👨‍💻

How to Get Started 🚀

Over the coming weeks, we’ll guide you through:

✅ SQL Fundamentals
✅ Intermediate SQL
✅ Advanced SQL
✅ Database Operations
✅ Writing Efficient Queries

Once you grasp the basics, practice is key! Start working on real-world projects and solving hands-on data problems.

What’s Next? ➡️

This is the first of many posts about the upcoming SQL Courses. It will only explain what SQL is in its crude form.

To get the full experience and fully immersed in the learning:

👉 Subscribe to Databites.tech (By Josep)

👉 Subscribe to Non-Brand Data (By Cornellius)

👉 Check out the SQL Crash Course GitHub repo

👉 Share with your friend and whoever needs it!

Let’s dive in and make SQL less scary, more fun, and way more useful! 🚀

Josep & Cornellius

Hi everyone! Josep and Cornellius Yudha Wijaya from Non-Brand Data here 👋🏻

As promised, today we are publishing the next two issues of our SQL Crash Course – From Zero to Hero! 🚀

I am sure you are here to continue our SQL Crash Course Journey!📚

If this is your first time or you’ve forgotten what we’ll cover, we will examine seven key SQL topics, each divided into multiple posts across Non-Brand Data and DataBites.

Remember last Thursday we already saw

📌 #1 What is SQL?

📌 #2 Why learn SQL?

Today’s turn is for:

📌 #3 Relational Data & Models by me in DataBites

📌 #4 Basic Commands by Cornellius Yudha Wijaya in Non-Brand Data

So, let’s dive in!

SQL & NoSQL Databases

Databases are the backbone of data science and application development, determining how data is stored, retrieved, and processed.

There are two main types of databases:

• SQL (Structured Query Language) → Relational

• NoSQL (Not Only SQL) → Non-Relational

They both serve different purposes depending on the nature of the data and the application requirements. This lesson delves into SQL databases, their characteristics, advantages, and real-world applications.

Subscribe now

What is Relational Model?

Now you might be wondering... what is really a Relational Model?

So let's try to understand this concept easily.

The relational model organizes data into tables where each record is stored as a row and attributes are represented as columns.

Relationships between tables are established using keys, such as:

• Primary keys (unique identifiers for each record)

• Foreign keys (linking records across tables).

This structure ensures data consistency and allows for complex queries by connecting related information efficiently.

So let's go step by step...

Imagine we run a couple of Newsletters (*wink wink*). We will have a Newsletter table that will register all our newsletters and then a second Posts table that will collect all published posts.

So now we have two main tables: NEWSLETTERS and POSTS.

In this case the records of both tables are easily relatable using:

• The id column in the NEWSLETTERS table, which uniquely identifies each newsletter. This serves as the Primary Key.

• The newsletter_id column in the POSTS table, which associates each post with its corresponding newsletter. This acts as the Foreign Key.

1.1 Characteristics of SQL Databases

In SQL databases, the relational model serves as the conceptual foundation, organizing data into structured and interconnected tables. SQL databases are made up of schemas and tables:

• Schema: defines the structure of the database, including tables, their fields, data types, available values, and relationships.

• Tables: The foundational units of a database, representing entities with rows containing individual records for each entity and columns storing specific attributes about the entity.

• Keys and Relationships

  • Primary Key: A unique identifier for each record in a table (id in the Product Table).

  • Foreign Key: A column that establishes a relationship between two tables ( product_id in a Sales table referencing Products).

  • Supports one-to-many and many-to-many relationships between tables.

• Normalization

  • The process of organizing data to reduce redundancy and improve consistency.

SQL, or Structured Query Language, serves as the interface for managing these databases, enabling the creation, retrieval, updating, and deletion of data through standardized commands. A list of these commands and SQL’s capabilities can be seen in my SQL Basics Cheat Sheet.

1.2 Advantages of SQL

SQL provides a standard set of commands for defining, querying, updating, and administering data in a relational database management system (RDBMS). Key SQL operations include:

• SELECT (querying data)

• INSERT (adding new records)

• UPDATE (modifying existing records)

• DELETE (removing records)

When using these commands, SQL ensures that ACID (Atomicity, Consistency, Isolation, and Durability) properties are maintained.

This ensures the reliability and consistency of database changes.

• Atomicity: Ensures that each transaction is treated as a single, indivisible unit of work. If any part of the transaction fails, none of its changes are applied to the database. Either the entire transaction is committed, or none of it takes effect.

• Consistency: Guarantees that a transaction transitions the database from one valid state to another, preserving predefined integrity constraints. The database remains consistent both before and after the transaction.

• Isolation: Ensures that concurrent transactions do not interfere with each other, preventing inconsistencies. Each transaction executes as if it were the only one running, maintaining data integrity even in a multi-user environment.

• Durability: Ensures that once a transaction is committed, its changes are permanently recorded in the database. The effects persist even in the event of system failures, such as crashes or power outages.

These fundamental properties of SQL databases ensure that database systems are reliable and consistent, even in the case of unexpected events or system failures.

Subscribe now

1.3 Common SQL Databases

There are three commonly used RDBMS:

• MySQL: An open-source RDBMS, now maintained by Oracle, known for its speed, reliability, and ease of use. It is widely used in LAMP stacks (Linux, Apache, MySQL, PHP/Python/Perl) and is a popular choice for small to medium-sized web applications.

• PostgreSQL: A powerful open-source object-relational database system with advanced capabilities, including support for custom functions, complex queries, indexing, and ACID-compliant transactions. It is well-suited for large-scale applications, data warehousing, and geospatial data processing.

• Microsoft SQL Server: A proprietary RDBMS developed by Microsoft, available in multiple editions (Express, Standard, Enterprise) to cater to different use cases. It seamlessly integrates with the Microsoft ecosystem, making it a strong choice for businesses of all sizes, from small enterprises to large corporations.

How to Get Started 🚀

Over the coming weeks, we’ll guide you through:

✅ SQL Fundamentals
✅ Intermediate SQL
✅ Advanced SQL
✅ Database Operations
✅ Writing Efficient Queries

Once you grasp the basics, practice is key! Start working on real-world projects and solving hands-on data problems.

What’s Next? ➡️

This is the first of many posts about the upcoming SQL Courses. It will only explain what SQL is in its crude form.

To get the full experience and fully immersed in the learning:

👉 Subscribe to Databites.tech (By Josep)

👉 Subscribe to Non-Brand Data (By Cornellius)

👉 Check out the SQL Crash Course GitHub repo

👉 Share with your friend and whoever needs it!

Let’s dive in and make SQL less scary, more fun, and way more useful! 🚀

Josep & Cornellius

As promised, today we are starting our SQL Crash Course, which will take you from zero to hero!🚀

As a reminder, we will cover seven SQL key topics, each separated into multiple posts across Non-Brand Data and DataBites.

Today’s turn is for:

📌 What is SQL? by in

📌 Why learn SQL? by me in

So, let’s dive in!

Why SQL? 🚀

If you're looking to break into data science, one of the biggest questions is:

👉 What tool should I learn first?

The answer? SQL.

SQL remains the #1 data language and is by far the easiest to learn. If you want to succeed in data science, here’s the best advice we can give you:

START
LEARNING
SQL
RIGHT
NOW!

Still unsure? Let’s break it down. 👇🏻

The Power of SQL 🔥

Humankind has always been strongly shaped by its ability to store and share information. Studies indicate that a key distinction between humans and other animals lies in our ability to create, preserve, and inherit knowledge and culture across generations.

And guess what… all of this is just DATA!

Today we are amid a significant shift in how our world works:

Data has become the fuel of the XXI century.

All fields and sectors rely on it to make decisions.

One thing is certain: The need for data-related skills will only keep surging.

Organisations today gather raw data from both internal and external sources at an unprecedented rate. By analysing this data, they can use reporting applications, dashboards, and other tools to answer questions and gain valuable insights.

So the right question to be done is how to manage all this data?

And the answer is quite simple: SQL remains the best option to do so.

But why SQL specifically? 🤔

Check out the StackOverflow Developer Survey 2024—SQL ranks as the 2nd (‼️) most used programming language (and #1 in data science 🥇).

Now, let’s explore SQL’s biggest advantages.

So let’s try to understand better SQL’s advantages 💥

SQL’s main advantages

#1. It can deal with big amounts of Data

SQL is designed to work with big data and can handle complex queries on large datasets much faster than other tools like spreadsheets or even some programming languages like Python.

Learning SQL helps you manage and analyze big data effectively.

In many organizations, the core of the data environment is typically a data warehouse, where SQL is the primary language for interaction.

#2. It can be easily integrated with other tools

SQL integrates seamlessly with other data science tools and programming languages, such as Python and R. Libraries like pandas (Python) and dplyr (R) allow you to run SQL queries directly within your code.

This interoperability makes it easier to combine SQL's data handling capabilities with the advanced analytics, visualization and ML features of these languages.

#3. It is standardized

To query or manipulate data with SQL, you use statements with keywords such as SELECT and FROM. This SQL syntax is standardized by ANSI and ISO-certified, ensuring consistency across the hundreds of databases and data tools that support SQL today.

While some databases and tools may extend the syntax with specialized operators, commands, or functions, the fundamental principles of SQL remain consistent.

Once you master the basics of SQL, you can apply this knowledge universally across different platforms.

#4. It is easy to understand

Basic SQL syntax is highly readable, resembling natural language. It outlines how data should be retrieved or manipulated.

Consider the following example query:

SELECT 
    first_name, 
    last_name, 
    date_of_hire
FROM employees
WHERE date_of_hire > '2018-12-31'
ORDER BY date_of_hire, last_name

In this query, the SQL keywords SELECT, FROM, WHERE, and ORDER BY define the actions to be performed and any person can understand the main purpose of the query.

⚠️ Pro Tip: SQL keywords don’t need to be capitalized, but doing so improves readability.

How to Get Started 🚀

Over the coming weeks, we’ll guide you through:

✅ SQL Fundamentals
✅ Intermediate SQL
✅ Advanced SQL
✅ Database Operations
✅ Writing Efficient Queries

Once you grasp the basics, practice is key! Start working on real-world projects and solving hands-on data problems.

What’s Next? ➡️

This is the first of many posts about the upcoming SQL Courses. It will only explain what SQL is in its crude form.

To get the full experience and fully immersed in the learning:

👉 Subscribe to Databites.tech (By Josep)

👉 Subscribe to Non-Brand Data (By Cornellius)

👉 Check out the SQL Crash Course GitHub repo

👉 Share with your friend and whoever needs it!

Let’s dive in and make SQL less scary, more fun, and way more useful! 🚀

Josep & Cornellius

Today I’m teaming up with Cornellius from to bring you something special—a brand-new SQL Crash Course! 🎉

Whether you're just starting out or looking to sharpen your SQL skills, this series will take you from zero to hero with a structured, easy-to-follow approach. Each post will break down essential SQL concepts, helping you crash into SQL with confidence, following the same style of my previous SQL courses.

🔥 What’s in the course?

We will structure the series into seven key topics to guide you step by step:

1. Introduction – What SQL is and why it matters

2. SQL Fundamentals – Basic commands, filtering, and aggregation

3. Intermediate SQL – Joins, unions, and functions

4. Advanced SQL – Subqueries, CTEs, recursion, and views

5. Database Operations – CRUD, schema changes, and optimization

6. Crafting Good SQL Queries – Best practices for writing efficient queries

7. Real-world Problems – Applying SQL to practical challenges

🎯 Who is this course for?

This SQL Crash Course is designed for two main audiences:

- Juniors & Beginners

If you're new to SQL or want to crash into the world of databases, this course will guide you step by step, making SQL easy and approachable.

- Seasoned Professionals & Seniors

In the later editions, we’ll tackle real-world projects and develop end-to-end solutions that you can add to your portfolio, helping you level up your skills and showcase practical experience.

No matter where you are in your SQL journey, this course will help you learn, apply, and master SQL with real examples and structured learning.

🗓️ When will it be available?

We’ll post the first two issues this Thursday, 13th March! ⚠️

Afterwards, every Thursday, you will have two new issues right in your inbox!

Make sure to subscribe to both databites.tech and Non-Brand Data!! 👀

💡 Where to find it?

We’ll be publishing weekly issues in both our newsletters:

• Databites.tech (By Josep)

• Non-Brand Data (By Cornellius)

We will make it open-source on GitHub so you can follow along, experiment, and contribute!

👉 Check out the GitHub repo and stay tuned for the first post!

📚 SQL Crash Course – Published Articles

1️⃣ Introduction to SQL

✅ #1. What is SQL? → link
✅ #2. Why Learn SQL? → link
✅ #3. Relational Data & Models → link

2️⃣ SQL Fundamentals

✅ #4. Basic Commands (SELECT, FROM, WHERE) → link
✅ #5. Sorting & Limiting (ORDER BY, LIMIT)→ link
✅ #6. Aggregate Functions (SUM, AVG, COUNT, etc.) → link

3️⃣ Intermediate SQL

✅ #7. JOINS (INNER, LEFT, RIGHT, FULL) → link
✅ #8. UNION & UNION ALL → link
✅ #9. Case Expressions → link
✅ #10. Functions (String, Date, Numeric) → link

4️⃣ Advanced SQL

✅ #11. Subqueries → link
✅ #12. Common Table Expressions (CTEs) → link
✅ #13. Recursion → link
✅ #14. Views → link

5️⃣ Database Operations

✅ #15. CRUD operations (INSERT, UPDATE, DELETE) → link
✅ #16. Database modifications (ALTER, DROP, CREATE) → link
✅ #17. Indexing & Optimization → link

6️⃣ Crafting Good SQL queries

✅ #18. Modular Code → link
✅ #19. SQL Execution Order → link
✅ #20. Query Optimization → link

Let’s dive in and make SQL less scary, more fun, and way more useful! 🚀

Josep & Cornellius