Forem: Slava Rozhnev

Is SQLZoo good for learning SQL

Slava Rozhnev — Sun, 24 May 2026 14:19:54 +0000

Table of Contents

Is SQLZoo Good for Learning SQL? A Quick Answer
How SQLZoo Works: Inside the Interactive Learning Engine
Where SQLZoo Falls Short: Why Learners Often Get Stuck
The Step-by-Step Approach to Mastering SQL
Common Mistakes to Avoid When Practicing SQL
What the Data Says About SQL Learning Tools
How We Approach This at SQLtest.online
Frequently Asked Questions

Is SQLZoo good for learning SQL? Yes, for building hands-on syntax intuition through immediate feedback, but it leaves major gaps in database theory and interview readiness that you'll need a dedicated platform to fill.

At SQLtest.online, we see learners arrive comfortable with SELECT and JOINs but unable to explain basic normalization. That's the SQLZoo effect: fast syntax, weak theory. Let's walk through what the platform does well and where you should look next.

Is SQLZoo Good for Learning SQL? A Quick Answer

Our students often ask: Is SQLZoo good for learning SQL? The short answer is yes, with a big "but."

SQLZoo is a free, interactive platform where you write live queries against real databases. A Kaggle resource roundup, 7 best free resources for learning SQL, lists it as a beginner-friendly, wiki-based tutorial with lessons you work through in the browser. That makes it a fantastic starting point. You learn by doing, and the feedback is instant.

But SQLZoo isn't a complete training system. It's light on theoretical depth, progress tracking, and interview simulation. Think of it as the driving range for learning golf. You can groove your swing, but you never play a round under tournament conditions.

It answers the question "Is SQLZoo good for learning SQL?" with a qualified yes for beginners and a clear no for interview prep.

How SQLZoo Works: Inside the Interactive Learning Engine

SQLZoo's format is simple. Wiki-based tutorials introduce a topic. Interactive exercises run against a live database. Immediate feedback tells you whether your query is correct.

The platform covers a wide range of topics. You move from basic SELECT statements to JOINs, subqueries, and aggregate functions, and the exercises support engines like PostgreSQL and MySQL. The hands-on modules are what SQLZoo is best known for.

Lobnig et al. (2026), in their overview of narrative online SQL learning tools, highlight how platforms like SQLZoo make database practice accessible. Anyone with an internet connection can start writing SQL right away. No installs, no configuration.

How does SQLZoo handle advanced topics like window functions?

SQLZoo includes a section for window functions. It introduces ROW_NUMBER, RANK, and aggregate windowing, and it's a decent first exposure.

Still, the explanations are brief. Learners often need to supplement this section with outside reading or a structured course to really understand partitioning and framing.

What are the benefits of using SQLZoo?

The primary benefit is the lack of setup. You open a browser and start writing SQL. The variety of non-trivial datasets (a world database, a movie database, and more) gives you realistic practice data.

Another benefit is the price. SQLZoo is completely free. There are no paywalls and no premium tiers, which makes it one of the most accessible tools for new learners exploring a career in data.

Where SQLZoo Falls Short: Why Learners Often Get Stuck

What are the main weaknesses of SQLZoo?

The most common complaint is the lack of theoretical grounding. Learners master puzzles but struggle with the concepts behind them. There are no performance benchmarks either, so a correct query is scored the same as an efficient one.

The interface also hasn't seen major updates in years. It feels like a tool from the early 2010s, and navigation between sections can confuse absolute beginners.

Can SQLZoo prepare you for technical interviews?

Not really. Interview preparation is almost nonexistent. SQLZoo teaches you to write SQL. It doesn't teach you to think about SQL under pressure. That's why learners often stall after finishing the tutorials. They don't know their skill level or what to practice next.

The platform offers window function exercises, but many people skip them because the explanations are thin. In a real interview, you need to explain your reasoning and optimize your query, not just produce a passing result.

The Step-by-Step Approach to Mastering SQL

Is SQLZoo good for learning SQL without a mentor?

It depends on your learning style. Some people thrive on a puzzle-like format. Others need structured guidance. Here's the approach we recommend.

First, use SQLZoo for initial syntax. Work through SELECT, JOIN, and subquery tutorials, and type every query yourself. Don't copy-paste the answers.

Next, pair that practice with theory. A theory checkpoint like SQL Interview Questions #2: What is DBMS? explains the "why" behind the syntax so the patterns actually stick.

Then practice multi-table queries on a task that challenges you. SQL Practice #6: Find all the actors in the film asks for a real JOIN against related tables, with immediate feedback.

Finally, test yourself with interview-style questions. SQL Interview Questions #9: What are DQL commands? bridges the syntax-to-theory gap that SQLZoo leaves open.

Common Mistakes to Avoid When Practicing SQL

Why do learners stop after using SQLZoo?

We see three habits that lead to stagnation.

The most common one is skipping the theory. SQLZoo lets you guess syntax until an exercise passes. Without theory, you don't understand why the query works, so when the problem changes slightly, you're lost.

A subtler mistake is dodging window functions. SQLZoo covers them, but learners often find the logic confusing, skip ahead, and miss a skill that shows up in many junior data interviews.

The most expensive mistake is ignoring query performance. In the real world, a slow query is a broken query. SQLZoo doesn't measure execution time, so you learn to produce correct output rather than efficient output.

What is the role of theory in SQL practice?

Theory explains the "why" behind the query. Without it, you're memorizing patterns instead of understanding logic. Try SQL Practice #7: Find all films of an actor for an exercise that tests your understanding of JOINs and subqueries alongside the underlying database design.

What the Data Says About SQL Learning Tools

Let's look at the bigger picture. Lobnig et al. (2026) praise tools like SQLZoo for lowering the barrier to entry, but they note that higher-level skills need platforms with more scaffolding.

This connects directly to the theory gap. You can write JOINs without understanding normal forms, but you'll struggle with interview questions on database design. If you want to see how the relational model fits together, the SQL standard overview on Wikipedia is a solid, neutral primer.

Is SQLZoo good for learning SQL compared to modern platforms?

Structured learning providers like Coursera emphasize that courses with graded assessments and a clear path tend to keep learners engaged longer than open-ended exercises alone. SQLZoo is beginner-friendly, but it isn't built to be your sole resource on the way to a professional role.

To fill the gaps, you want progress tracking, categorized difficulty, and interview-style practice. Syntax drills are only one piece of the puzzle.

How We Approach This at SQLtest.online

At SQLtest.online, we built the platform to close the gaps SQLZoo leaves open. We offer:

Interactive SQL exercises with immediate feedback.
Tasks grouped by complexity, category, and database.
Theory questions covering SQL fundamentals.
Interview preparation with realistic scenarios.

You get immediate feedback, progress tracking, and a clear path from beginner to job-ready. We combine the hands-on practice of a tool like SQLZoo with the theoretical depth of a textbook and the pressure of a technical interview.

Take SQL Interview Questions #5: The Release Strategy to see how we frame real interview logic. Then try SQL Practice #22: Find the films never been rented, a common interview ask that needs a multi-table JOIN and a subquery. It tests the exact skills SQLZoo leaves underdeveloped. We believe learning SQL means mastering both syntax and theory, so our students leave ready for their first data role, not just the next tutorial.

Frequently Asked Questions

Is SQLZoo free to use?

Yes. SQLZoo is completely free, with no paywalls or premium tiers. You can start writing queries in your browser without creating an account.

Is SQLZoo good for SQL interview preparation?

On its own, no. SQLZoo builds syntax fluency but doesn't simulate interviews, track progress, or push you on query performance. Pair it with interview-style practice to close that gap.

Does SQLZoo cover advanced SQL topics?

Partly. It introduces window functions, subqueries, and aggregates, but the explanations are brief, so advanced topics usually need extra reading or a structured course.

Is SQLZoo good for complete beginners?

Yes, for syntax. The instant-feedback exercises are a great first step. Beginners should add a theory resource early so they understand why each query works, not just that it passes.

What should I use alongside SQLZoo?

Combine SQLZoo's syntax drills with a platform that adds theory questions, difficulty grouping, and interview simulation so your skills transfer to real work and interviews.

Learn SQL Online Free for Beginners: Complete 2026 Guide

Slava Rozhnev — Sun, 24 May 2026 13:03:55 +0000

Learning SQL online for free as a beginner means using no-cost, browser-based platforms and tutorials to master the Structured Query Language, the standard tool for managing and querying relational databases, without needing prior programming experience or paid subscriptions. It is an entirely achievable goal with today's wealth of free resources.

Table of Contents

What Does It Mean to Learn SQL Online Free for Beginners?
What Exactly Is SQL and Why Should Beginners Learn It?
How Free Online SQL Learning Actually Works
The Best Free Path to Learn SQL: A Beginner's Step-by-Step Plan
How to Choose the Right Free SQL Learning Platform: Key Evaluation Dimensions
Common Mistakes Beginners Make When Learning SQL Online for Free
When Free Online SQL Learning Is Right for You, and When It Isn't
How SQLTest.online Fits Into Your Free Learning Journey
Frequently Asked Questions About Learning SQL Online for Free

This guide will help you learn SQL online free for beginners with clarity and confidence. Let's get started.

What Does It Mean to Learn SQL Online Free for Beginners?

Is it really possible to learn SQL online for free?

Yes, and it happens more often than you might think. Plenty of people have moved into data roles using only free materials. You don't need a degree or a paid bootcamp. The resources exist and they work.

What does a typical free SQL learning path look like?

It starts with understanding what a database is and how SQL fits in. Then you learn to retrieve data with SELECT, filter with WHERE, and sort with ORDER BY. After that comes grouping and aggregation. JOINs follow, then subqueries and set operations. Finally, you tackle window functions and CTEs.

Many learners progress through these milestones:

Early focus: Basic SELECT, WHERE, ORDER BY
Next focus: GROUP BY, HAVING, basic JOINs
Then: More JOINs, subqueries, UNION
Later: Window functions, common table expressions

The whole journey can take a couple of months of daily work. The key is writing queries every day, not just reading about them.

What Exactly Is SQL and Why Should Beginners Learn It?

SQL stands for Structured Query Language. It is the universal language for managing relational databases. Data analysts, software developers, and database administrators all use it regularly. According to Wikipedia, SQL is designed for managing data held in a relational database management system.

The demand is real, too. The U.S. Bureau of Labor Statistics tracks strong projected growth for database and data-related roles, and SQL is the skill those jobs assume you already have.

Why learning SQL for free is a smart choice

Effective SQL practice for beginners is hands-on. By choosing free resources, you remove financial risk. You can explore the language without any upfront investment, decide whether data work suits you, and only later pay for a course if you want a formal credential.

How does SQL compare to other programming languages?

SQL is declarative. You describe the result you want, not the steps to get it. This makes it easier to learn than Python or Java for many people. Beginners often write useful queries within their first hour of practice.

Common uses for SQL:

Data analysts extract insights from company databases.
Developers manage application data with SQL.
Business intelligence professionals build reports and dashboards.

How Free Online SQL Learning Actually Works

Free online SQL platforms use a learn-by-doing model. You read a short lesson and then write real queries against a live database. The system checks your output and gives immediate feedback.

This active approach is the reason interactive practice tends to stick. When you type a query and immediately see whether the result is right or wrong, each attempt becomes a small experiment. That feedback loop builds understanding far faster than watching a video or reading a chapter and hoping it lands.

What makes free online SQL learning effective?

Active practice is the key. Instead of passively watching videos, you type code. This builds retention and understanding. Mistakes become immediate learning opportunities because you see the results.

How do interactive platforms teach SQL?

Platforms like Khan Academy provide structured lessons with built-in editors. You write queries in the browser and see results instantly. This removes setup friction and lets you focus on learning. W3Schools offers a similar try-it editor alongside a reference you can return to whenever syntax slips your mind.

Key features that make interactive learning work:

Immediate feedback on each query.
Ability to learn at your own pace.
No software installation needed.
Access to realistic sample databases.

The Best Free Path to Learn SQL: A Beginner's Step-by-Step Plan

Follow this step-by-step plan to learn SQL online free for beginners

This path takes you from beginner to advanced topics, and you can complete every stage below for free.

Start with the fundamentals. Master SELECT, FROM, WHERE, and basic filtering. Use a resource like Khan Academy's Intro to SQL. Write your first queries and get comfortable with simple data retrieval.
Practice daily. Use an interactive platform and set a timer for 20 minutes. Solve a few exercises each day. Consistent practice builds confidence faster than long weekend sessions. A short daily habit beats a four-hour cram once a week.
Learn JOINs and aggregation. Master INNER JOIN, LEFT JOIN, and GROUP BY. These skills appear in almost every real-world query. Combining tables is where SQL starts to feel powerful, so spend extra time here until multi-table queries feel natural.
Tackle subqueries and set operations. Learn how to nest queries and combine result sets with UNION. These techniques appear frequently in reporting and analytics.
Work on analytical problems. Explore window functions, common table expressions (CTEs), and recursive queries. Our SQL Practice #31: Frequently Purchased Product Pairs is a good challenge for this stage.
Prepare for interviews. Practice theory alongside queries. Questions like SQL Interview Questions #9: What are DQL commands? and What is DBMS? test the fundamentals interviewers ask about most.

Each stage builds on the previous one. Do not rush. Mastery comes from repetition.

How to Choose the Right Free SQL Learning Platform: Key Evaluation Dimensions

When picking a platform to learn SQL online free for beginners, consider these factors:

Interactivity: Does the platform let you write real queries or just watch videos? Active learning beats passive watching.
Database variety: Does it support MySQL, PostgreSQL, SQL Server, or a custom dialect? Broad exposure helps you adapt later.
Progression structure: Does it have a clear beginner-to-advanced path or is it random exercises? Structure keeps you moving forward.
Feedback quality: Does it show expected output and explain mistakes, or just mark right or wrong? Good feedback accelerates learning.
Community and support: Are there forums, comments, or mentors? Getting stuck is easier with help available.
Cost: Is it truly free or freemium with paywalled content? Read the fine print before committing.
Mobile-friendliness: Can you practice on a phone? Some platforms offer responsive designs for on-the-go practice.

Test a few platforms before deciding. The one that feels right is the one you will stick with.

Common Mistakes Beginners Make When Learning SQL Online for Free

The most common mistake is skipping the basics. Beginners often jump to complex JOINs before they truly understand WHERE clauses and data types, and the result is frustration and slow progress. A few hours spent getting filtering right pays off across every query you write afterward.

A subtler trap is assuming all SQL is identical. Dialects differ: MySQL, PostgreSQL, and SQL Server vary in functions, date handling, and syntax. If you only ever practice on one system, a different dialect in a job or interview can throw you. Expose yourself to more than one early.

Another expensive habit is reading without writing. Tutorials feel productive, but passive reading creates false confidence. You only learn SQL by typing queries, running them, and fixing what breaks. Treat every error message as a clue rather than a wall, and debug systematically instead of guessing.

Finally, many beginners practice inconsistently. Twenty focused minutes a day will outpace an occasional marathon session, because the daily habit keeps concepts fresh while you layer new ones on top.

When Free Online SQL Learning Is Right for You, and When It Isn't

Free online learning fits most beginners beautifully. It suits career changers testing whether they enjoy data work, students supplementing a university course, professionals who need to query customer or product data for their actual job, and hobbyists who simply want to understand their own datasets. If that describes you, free resources will carry you a long way.

It is a weaker fit in a few situations. If you need a formal certification for a regulated field, if you learn best with deadlines and an instructor holding you accountable, or if you are targeting a niche system with little free practice material, structured paid options make more sense. Once you have worked through the free path, a credential-bearing course can be a reasonable next step.

How SQLTest.online Fits Into Your Free Learning Journey

We built SQLTest.online as a free, interactive practice companion rather than a replacement for any tutorial you enjoy. Our exercises are grouped by complexity, category, and database, so you can move from your first SELECT toward analytical challenges at a pace that matches your progress. We cover MySQL, PostgreSQL, SQL Server, SQLite, and Firebird, which means you practice across dialects instead of getting locked into one.

We are especially useful once you have finished an introductory course and need structured repetition to make skills permanent. You can copy query results to your clipboard, work through interview-style theory questions, and tackle real-world problems drawn from realistic databases. If you want background reading, our about page explains the approach and our recommended SQL books point you toward deeper study. Think of us as the place you go to practice what you have learned until it sticks.

Frequently Asked Questions About Learning SQL Online for Free

Is it possible to learn SQL for free?

Yes. Free, interactive platforms and tutorials cover everything from basic SELECT statements to window functions, and many people reach a working level without ever paying for a course.

How long does it take a beginner to learn SQL?

With consistent daily practice, most beginners write basic queries within a few weeks and reach intermediate topics like JOINs and aggregation within two to three months. Consistency matters more than speed.

Do I need to know programming before learning SQL?

No. SQL is declarative and designed to be readable, so you describe the result you want rather than coding step-by-step logic. Many people learn SQL as their first technical skill.

Can I learn SQL on my phone?

You can read lessons and review concepts on a phone, and some platforms are mobile-friendly. Writing and testing real queries is easier on a desktop or tablet where you have a proper keyboard.

What is the best free way to practice SQL for beginners?

The best approach combines a structured tutorial for concepts with an interactive platform for daily practice. Learn a topic, then immediately write queries against a real database until it feels natural.

Practice SQL JOINs Online Free: Master Multi-Table Queries

Slava Rozhnev — Sat, 23 May 2026 13:16:53 +0000

Practicing SQL JOINs online free means using interactive platforms that provide sample databases and real-time query feedback without any cost. This hands-on approach lets you write INNER, LEFT, RIGHT, and FULL OUTER JOINs against actual data tables, building muscle memory for multi-table queries that hiring managers test in technical interviews.

Unlike reading a syntax reference, active practice forces you to think through key relationships, handle NULLs, and debug unexpected row counts. When you practice JOINs online for free, you get immediate feedback on your syntax and logic. This turns passive learning into active skill building.

Many beginners read about JOINs but never write one until an interview. That gap costs confidence. The best way to close it is to practice SQL JOINs online free with real datasets that mimic production environments.

Table of Contents

What Does It Mean to Practice SQL JOINs Online Free?
Why Traditional SQL JOIN Tutorials Fall Short for Real-World Skills
A Three-Step Framework to Master SQL JOINs Through Practice
How to Evaluate a Free SQL JOIN Practice Platform: Key Dimensions
Three Mistakes That Sabotage Your SQL JOIN Practice and How to Fix Them
Why We Built SQLtest.online for Hands-On JOIN Practice
When to Commit to a Structured JOIN Practice Routine: Three Signals
How SQL JOIN Practice Prepares You for Technical Interviews

What Does It Mean to Practice SQL JOINs Online Free?

An SQL JOIN is a clause that combines rows from two or more tables based on a related column. The Wikipedia entry on SQL joins defines a join as an operation that combines columns from two or more tables into a single result set based on matching values. Without JOINs, you cannot answer questions that span multiple tables.

When you practice SQL JOINs online free, you write queries against live databases. You see results instantly. You compare your output against expected results. This feedback loop is what builds real skill.

What is an SQL JOIN and why does it matter?

JOINs are the backbone of relational database queries. Every data professional, from analyst to backend developer, uses them daily. The MySQL JOIN reference shows how an INNER JOIN matches rows across two tables on a shared key, merging the matched rows into a single result set.

Knowing how to write accurate JOINs separates a beginner from someone who can work with real data. Interviewers test JOIN skills repeatedly because incorrect JOINs produce wrong answers that are hard to catch.

How can I practice SQL JOINs online free with sample databases?

You can practice SQL JOINs online free by signing up for platforms that offer interactive SQL editors pre-loaded with sample databases. These platforms let you write queries against tables like customers, orders, products, and employees without setting up anything locally.

The key is finding a platform that gives you immediate result feedback. When you practice against sample databases, you should see your output instantly and compare it to expected results. This rapid feedback loop accelerates learning dramatically.

Why Traditional SQL JOIN Tutorials Fall Short for Real-World Skills

Reading a syntax reference or watching a video gives you passive knowledge. JOINs require active recall. When you face a real database with NULLs, duplicate keys, and unexpected row counts, static examples do not prepare you.

W3Schools has a reference page that lists INNER, LEFT OUTER, RIGHT OUTER, and FULL OUTER JOIN as the main join types. That reference is useful for syntax lookup. It is not useful for building the debugging instinct you need in a real job.

Most tutorials show clean, sanitized data. Real databases are messy. NULL values appear in join columns. Duplicate keys create unexpected row multiplication. The only way to learn how to handle these cases is through interactive SQL JOIN exercises that throw real-world scenarios at you.

Why do static tutorials fail to build practical JOIN skills?

Static tutorials present one correct answer and move on. They do not force you to reason about why a JOIN returned 50 rows instead of 100. They do not ask you to debug a query that runs but produces wrong results.

When you practice on a platform with feedback, you learn to reason about row counts. You predict how many rows each JOIN type will return given the data. That predictive skill is what interviewers test and what jobs require.

How does interactive SQL JOIN practice fill the gap?

Interactive platforms let you experiment. You write a LEFT JOIN, see the result, then rewrite it as an INNER JOIN and compare. That cause-and-effect observation builds intuition faster than any book.

DataLemur's SQL JOIN tutorial states that an INNER JOIN returns only rows with matching values from both tables. A LEFT JOIN returns all rows from the left table plus matching rows from the right table. Reading that definition is step one. Writing both JOINs on the same tables and comparing row counts is where the learning sticks.

A Three-Step Framework to Master SQL JOINs Through Practice

This framework builds from simple to complex. Each step depends on the previous one, so follow them in order.

Start with single-table queries. Confirm you understand the base tables, their columns, row counts, and key relationships. Before you can join two tables, you need to know what each table contains and which columns link them.
Write INNER JOINs on two tables using a foreign key. Verify row counts match expectations. An INNER JOIN should return fewer rows than the larger table unless every row has a match. Compare your result count against a known correct count.
Progress to LEFT JOINs, then multi-table JOINs, then self-joins and full outer joins. Each step adds complexity. Multi-table JOINs with three or more tables test your ability to chain relationships. Self-joins and full outer joins appear in advanced scenarios and interview questions.

Step 1: Understand your base tables first

Many beginners try to JOIN before they understand the source tables. This leads to confusion when the result set does not make sense. Spend time exploring each table's columns, data types, and row counts before writing a JOIN.

Start by running SELECT * queries on each table. Note the primary key and any foreign key columns. This groundwork makes JOIN logic obvious later, and the PostgreSQL join tutorial walks through the same idea of qualifying columns by their table before combining them.

Step 2: Write INNER JOINs and verify row counts

An INNER JOIN returns only rows with matching values in both tables. If table A has 100 rows and table B has 200 rows, a well-written INNER JOIN on a foreign key should return at most 100 rows when the key is unique in A.

After you run your query, compare the row count against what you predicted. A mismatch means you need to debug your logic or check the data for NULLs. This verification habit separates competent SQL users from guessers.

Step 3: Progress to LEFT JOINs, multi-table queries, and self-joins

LEFT JOINs return all rows from the left table and matching rows from the right. This is essential for finding unmatched records. Multi-table JOINs chain multiple ON clauses to connect three or more tables.

Self-joins are especially tricky. In the "Using Self Joins" lesson, Deardurff (2019) explains that a self-join treats a single table as two separate instances with different aliases. This pattern is common in employee-manager hierarchies and duplicate-record detection.

Full outer joins combine both tables completely. As Wikipedia describes, a FULL OUTER JOIN returns all rows from both tables, with NULLs filled in where matches do not exist. This is useful for data reconciliation tasks.

JOIN Type	Returns	Use Case	Expected Row Count
INNER JOIN	Only matching rows from both tables	Finding records that exist in both datasets	Fewer than or equal to the smaller table
LEFT JOIN	All rows from left table plus matching rows from right	Finding records with optional related data	Equal to left table row count
RIGHT JOIN	All rows from right table plus matching rows from left	Same as LEFT JOIN but reversed	Equal to right table row count
FULL OUTER JOIN	All rows from both tables	Data reconciliation and comparing two datasets	Sum of both tables minus matches
CROSS JOIN	Every possible combination of rows	Generating all combinations	Row count of table A times row count of table B

How to Evaluate a Free SQL JOIN Practice Platform: Key Dimensions

Not all practice platforms are equal. Here are five dimensions to evaluate when choosing where to practice SQL JOINs online free.

Dataset variety: Does the platform offer multiple sample databases like e-commerce, HR, and library schemas so you practice JOINs in different contexts?
Query feedback: Does it show the result set immediately and highlight errors or unexpected row counts?
Progression structure: Are exercises grouped by complexity or thrown at you randomly?
Interview relevance: Do exercises mirror real interview questions like finding unmatched records or aggregating across joined tables?
Cost and access: Is the core JOIN practice truly free or are advanced exercises behind a paywall?

Dataset variety and real-world relevance

A platform with one sample database limits your exposure. Real jobs involve many different schemas. The more databases you practice against, the more flexible your JOIN skills become.

Look for platforms that offer e-commerce schemas with customers, orders, and products, plus library schemas with authors, books, and borrowers. Each schema tests JOINs in a different context.

Query feedback and error visibility

The best platforms show your result set immediately. They also make it easy to compare your output with the expected output. Some platforms highlight which rows differ or reveal the correct query after multiple attempts.

When you work through interactive SQL JOIN exercises, error visibility is crucial. A platform that simply says wrong answer without context teaches less than one that shows you where your result diverged.

Progression structure and interview readiness

The best platforms group exercises by complexity. You start with simple two-table INNER JOINs and progress to multi-table queries, self-joins, and analytic JOINs. This scaffolded approach builds confidence gradually.

Interview questions often require multi-table JOINs with aggregation and filtering. A good platform includes exercises that combine JOINs with GROUP BY, HAVING, and subqueries. For example, finding all films where a specific actor did not participate is a multi-table JOIN challenge that tests set-based thinking.

Platform	Exercise Types	Sample Databases	Query Feedback	Cost
SQLtest.online	Interactive SQL exercises grouped by complexity	Multiple databases	Immediate result set display	Free
SQLZoo	Step-by-step tutorial exercises	World, Nobel databases	Shows result set	Free
SQLBolt	Lesson-based interactive exercises	Single movies database	Shows result set	Free
DataLemur	Interview-style practice questions	Multiple databases	Expected vs actual output	Free tier available
HackerRank	Coding challenge problems	Multiple domains	Pass or fail with test cases	Free

Three Mistakes That Sabotage Your SQL JOIN Practice and How to Fix Them

These mistakes are common among beginners. Recognizing them early saves hours of debugging frustration.

Why does INNER JOIN drop rows unexpectedly?

The most common mistake is forgetting that INNER JOIN drops non-matching rows. Beginners see missing data and think the query is broken. In reality, the INNER JOIN is working correctly by only returning rows where the join condition succeeds.

The fix is to check your data. Do the join columns contain NULLs? Are there rows in one table without corresponding rows in the other? If you need all rows from one side, use a LEFT JOIN instead.

When should you use LEFT JOIN instead of INNER JOIN?

The subtler trap is using LEFT JOIN when INNER JOIN is correct, or vice versa. A LEFT JOIN introduces NULLs in the right-table columns for rows without matches. Those NULLs can cause downstream calculations to produce wrong answers.

Ask yourself: do I need every row from the left table even if there is no match in the right? If yes, use LEFT JOIN. If you only want rows that exist in both tables, use INNER JOIN. This distinction is tested frequently in interviews.

How does a missing ON clause create a Cartesian product?

The most expensive mistake is omitting the ON clause entirely. This produces a CROSS JOIN where every row from table A pairs with every row from table B. The result set multiplies, so 100 rows against 200 rows returns 20,000 rows.

The MySQL JOIN reference notes that CROSS JOIN and INNER JOIN are syntactically equivalent in MySQL, which is exactly why an accidental missing ON clause silently produces a Cartesian product. If your query returns far more rows than expected, check your JOIN syntax first.

Why We Built SQLtest.online for Hands-On JOIN Practice

We built SQLtest.online because we saw learners stuck between theory and interview readiness. They could recite JOIN syntax but froze when asked to write a three-table query in an interview.

Our platform offers interactive SQL exercises where you write real JOIN queries against multiple sample databases. You get immediate result-set feedback. We group tasks by complexity, category, and database so you can start with simple two-table INNER JOINs and progress to multi-table and self-join exercises.

The platform is free. We believe everyone should be able to practice SQL JOINs against a real sample database without financial barriers. We also support copying SQL code to the clipboard so you can save your work for later review.

How does SQLtest.online help you practice SQL JOINs online free?

SQLtest.online gives you a browser-based SQL environment with pre-loaded sample databases. You do not install anything. You do not configure anything. You just write queries and see results.

Our interactive SQL JOIN exercises range from beginner to advanced. We include theory questions that reinforce fundamentals covering what a database is, what DBMS means, and what RDBMS means. This foundation makes JOIN logic easier to understand.

We also prepare you for technical interviews. Our exercises mirror real interview patterns such as multi-table queries, finding unmatched records, aggregating across joined tables, and handling NULLs.

What types of JOIN exercises does SQLtest.online offer?

We offer exercises across multiple databases, including an AdventureWorks schema and a rental database. Each database has exercises grouped by difficulty.

For example, getting product category color counts requires joining product and category tables then aggregating results. This kind of multi-table grouping is a common interview question.

We also have exercises that test data manipulation with JOINs, such as creating a customer addresses view. These teach you that JOINs work in CREATE VIEW, UPDATE, and DELETE statements, not just SELECT queries.

When to Commit to a Structured JOIN Practice Routine: Three Signals

Knowing when to start, pivot, or change your approach is as important as the practice itself.

The build signal: start with two-table INNER JOINs

If you can write a basic SELECT but freeze when someone says join the orders and customers tables, that is your build signal. Start with two-table INNER JOINs immediately. Do not wait until you feel ready. Write your first JOIN query today.

Spend 15 minutes daily practicing. Consistency beats intensity. A focused 15-minute session where you write and debug JOIN queries is worth more than a three-hour tutorial binge once a week.

The pivot signal: switch to platforms that verify row counts

If you have done a few JOIN exercises but still cannot predict row counts before running the query, you need to pivot. Switch to a platform that shows expected versus actual row counts and forces you to reason before executing.

At SQLtest.online, we design exercises that help you build this predictive skill.

The abandon signal: stop passive learning

If you have been practicing by reading syntax references for weeks without writing a single JOIN query, drop that approach entirely. Passive learning creates the illusion of progress without building real skill.

Commit to active query writing. Open a browser, go to a free SQL JOIN practice platform, and write queries. The first one will be slow. By the tenth one, you will start to see patterns. By the fiftieth, JOINs will feel natural.

How SQL JOIN Practice Prepares You for Technical Interviews

Technical interviews for data roles almost always include JOIN questions. Interviewers want to see that you can combine data from multiple tables accurately and efficiently.

What interview questions test your JOIN skills?

Common interview JOIN patterns include:

Finding records in one table that do not exist in another using LEFT JOIN with IS NULL
Aggregating data across related tables using JOIN with GROUP BY
Comparing rows within the same table using self-joins
Handling NULLs in join columns using COALESCE with JOIN

For example, finding duplicate actor names tests a self-join pattern that appears in real interviews. You join a table to itself to find rows with matching values in certain columns.

How do multi-table JOINs appear in real interviews?

Interviewers often present a scenario: we have customers, orders, and products tables. Write a query to find the top 10 customers by total spending. This requires joining all three tables and using aggregation.

Another common pattern is finding employees who have never submitted an expense report. This tests LEFT JOIN with NULL filtering. Our total bookings amount exercise uses a similar pattern, joining transaction tables to calculate totals.

For more practice, try our average cost of renting a movie by category exercise. It combines JOIN operations with aggregate functions in a realistic context.

Frequently Asked Questions

How can I practice SQL JOINs online for free?

Use browser-based platforms like SQLtest.online, SQLZoo, or DataLemur that offer free interactive exercises with pre-loaded sample databases. You can write and run queries instantly without installing any software.

What is the best way to learn SQL JOINs?

Write queries daily against real datasets. Start with INNER JOINs and progress to LEFT, RIGHT, FULL OUTER, and self-joins. Focus on predicting row counts before running each query and compare actual results against your predictions.

Are there SQL JOIN practice questions with answers?

Yes. Platforms like HackerRank and SQLtest.online provide exercises with expected result sets so you can verify your output. Many platforms also show the correct query after you submit your attempt.

How do I practice SQL JOINs for interviews?

Focus on multi-table queries that find unmatched records, aggregate across joined tables, and handle NULLs. Patterns like LEFT JOIN with IS NULL and JOIN with GROUP BY appear frequently in technical interviews.

Can I practice SQL JOINs without installing software?

Yes. Browser-based platforms like SQLtest.online and SQLBolt let you write and run queries instantly without local setup. You only need a web browser and an internet connection to start.

How much time should I spend practicing SQL JOINs each day?

Fifteen minutes of focused daily practice is more effective than several hours once a week. Consistency builds the muscle memory you need for interviews and real-world query writing.

What is the difference between INNER and LEFT JOIN in practice?

An INNER JOIN drops rows that lack a match in the other table. A LEFT JOIN keeps all rows from the left table and fills in NULLs where no match exists. Use INNER JOIN when you only want matched records and LEFT JOIN when you need complete results from one side.

PostgreSQL Upgraded to Latest Minor Versions on SQLize.online 🐘🚀

Slava Rozhnev — Sat, 16 May 2026 09:34:17 +0000

As the owner of SQLize.online, I’m committed to providing a playground that doesn’t just let you write code, but lets you test against the most stable, secure, and "production-ready" environments possible.

That’s why I’ve just finished upgrading our PostgreSQL stack to the latest minor versions across the board!

🛠 What’s New?
The PostgreSQL Global Development Group recently pushed out a series of critical maintenance updates. These are now live and ready for you on the site:

PostgreSQL 18.4 (The latest stable)

PostgreSQL 17.10

PostgreSQL 16.14

PostgreSQL 15.18

🔒 Why Minor Versions Matter
In the world of databases, "minor" doesn't mean "unimportant." These updates address:

Security Patches: Protecting against recently discovered vulnerabilities.

Stability Fixes: Squashing edge-case bugs that could cause unexpected query behavior.

Performance Improvements: Minor tweaks to the query planner and indexing engine to ensure your tests reflect real-world efficiency.

🐘 Test Your Code Today
Whether you are practicing complex joins, testing out PostgreSQL 18 features, or verifying that your legacy queries still work on older versions before a migration, SQLize is updated and ready.

Fun Fact: PostgreSQL 14 is reaching its End of Life (EOL) in November 2026. If you're still on v14, now is the perfect time to use the SQLize sandbox to test your logic on v17 or v18!

Try it out now: sqlize.online

Happy querying!

Why `SUM() OVER (ORDER BY ...)` Sometimes Feels Wrong: A Practical Guide to SQL Window Frames

Slava Rozhnev — Wed, 11 Mar 2026 19:06:35 +0000

Window functions in SQL can make you feel productive very quickly. You learn PARTITION BY, add ORDER BY, use ROW_NUMBER(), RANK(), and running totals, and it feels like you already have the mental model.

That was exactly my mistake.

For a while, I thought I understood window functions well enough because my queries were working and the results looked plausible. The confusion only started later, when I began getting results that were syntactically correct but did not match what I expected logically.

A classic example looks like this:

SUM(amount) OVER (ORDER BY amount)

You expect a normal running total. Instead, the result suddenly jumps by multiple rows at once. No SQL error. No broken query. The database is doing exactly what you asked.

The missing piece is usually the same: the window frame.

The frame determines which rows around the current row are actually included in the calculation. Until that part clicks, window functions are easy to copy from memory but hard to control precisely.

For me, understanding frames was the point where window functions stopped feeling like a bag of handy tricks and started feeling like a consistent system.

When I want to test behavior like this quickly, I usually run the queries in a live environment. For quick experiments I use sqlize.online, and for more structured SQL practice and lessons I publish material on sqltest.online.

In this article, I want to walk through:

what a window frame actually is;
the difference between ROWS, RANGE, and GROUPS;
how boundaries like UNBOUNDED PRECEDING, CURRENT ROW, and n FOLLOWING work;
why the default frame can surprise you;
how to write running totals and moving averages without hidden assumptions.

What a window frame is

When we write a window function, we usually see something like this:

SUM(amount) OVER (
    PARTITION BY customer_id
    ORDER BY payment_date
)

When I first started using queries like this, I mentally translated them as: “the function is calculated over the whole customer_id partition in payment_date order.”

That is not quite right.

PARTITION BY defines which partition the window works inside.

ORDER BY defines the order of rows inside that partition.

The window frame defines which subset of rows from that partition is used for the current row’s calculation.

The full shape looks like this:

function_name() OVER (
    [PARTITION BY ...]
    [ORDER BY ...]
    [ROWS | RANGE | GROUPS BETWEEN ... AND ...]
)

So the mental model is really three layers:

Choose the partition.
Define the ordering inside that partition.
For each row, define the frame: where it starts and where it ends.

Why this matters

The same SUM() can mean completely different things depending on the frame:

a running total from the start of the partition to the current row;
a 3-row sliding window;
an average across the current row and future rows;
a full-partition aggregate without collapsing rows.

From the outside, these queries can look very similar. Their behavior is not similar at all. That is why window functions can seem simple right up until you hit the first result that looks weird in production.

Frame boundaries

A frame is usually defined with BETWEEN ... AND ....

The available boundaries are:

UNBOUNDED PRECEDING — start from the first row in the partition;
n PRECEDING — go n rows or logical steps backward;
CURRENT ROW — the current row;
n FOLLOWING — go n rows or logical steps forward;
UNBOUNDED FOLLOWING — continue to the last row in the partition.

For example:

ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

That is the classic running-total frame: from the start of the partition up to the current row.

`ROWS`, `RANGE`, and `GROUPS`: the real difference

This is where things usually become interesting.

`ROWS`

ROWS works with physical rows.

If you write:

ROWS BETWEEN 2 PRECEDING AND CURRENT ROW

that always means exactly three rows:

the current row;
the two previous rows.

It does not matter whether those rows have the same ORDER BY value or not. The count is based on row positions.

This is the most predictable mode. In most practical analytics work, especially when I need a fixed-width sliding window, ROWS is usually where I start.

`RANGE`

RANGE works with a logical value range, not physical rows.

If multiple rows share the same ORDER BY value, they can enter the frame together as one logical group.

That is why RANGE often surprises people.

The most important detail is this: if you specify ORDER BY but do not define a frame explicitly, many databases use this default:

RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

That means the calculation includes not only all rows before the current row, but also all rows that share the same ordering value as the current row.

If your ORDER BY column contains duplicates, the result can jump more than you expect.

`GROUPS`

GROUPS works with peer groups of equal ORDER BY values.

If ROWS counts rows and RANGE thinks in logical value ranges, GROUPS counts groups of equal values.

For example:

GROUPS BETWEEN 1 PRECEDING AND CURRENT ROW

means: take the current peer group and the previous peer group as whole units.

This is useful when your mental model is based on equal-value groups rather than individual rows. PostgreSQL supports it. Support in MySQL and MariaDB is more limited depending on version.

Example 1: running total

Let’s start with the most common case.

SELECT
    customer_id,
    payment_date,
    amount,
    SUM(amount) OVER (
        PARTITION BY customer_id
        ORDER BY payment_date
        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS running_total
FROM payment
WHERE customer_id = 1
ORDER BY payment_date;

What happens here:

rows are partitioned by customer_id;
rows inside the partition are ordered by payment_date;
for each row, the sum runs from the first row in the partition up to the current row.

This is the explicit, correct running-total pattern.

In my own queries, I almost always write this frame explicitly, even if the database would happen to return the expected result without it. Writing the frame makes the behavior obvious and protects you from subtle surprises later.

Example 2: moving average

Now let’s use a fixed-width window:

SELECT
    customer_id,
    payment_date,
    amount,
    ROUND(
        AVG(amount) OVER (
            PARTITION BY customer_id
            ORDER BY payment_date
            ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
        ),
        2
    ) AS moving_avg_3
FROM payment
WHERE customer_id = 1
ORDER BY payment_date;

For each row, the frame includes:

the current row;
the two previous rows.

So the maximum frame width is three rows.

This is a typical case where ROWS is the right choice and RANGE is not. The goal is a fixed number of rows, not a logical expansion around equal values.

Example 3: looking forward

Window functions can look ahead as well:

SELECT
    customer_id,
    payment_date,
    amount,
    ROUND(
        AVG(amount) OVER (
            PARTITION BY customer_id
            ORDER BY payment_date
            ROWS BETWEEN CURRENT ROW AND 2 FOLLOWING
        ),
        2
    ) AS forward_avg
FROM payment
WHERE customer_id = 1
ORDER BY payment_date;

This kind of frame is useful for things like:

smoothing;
local trend analysis;
short forward-looking comparisons.

Near the end of the partition, the frame naturally shrinks because there are no future rows left.

Example 4: full-partition aggregate without `GROUP BY`

Sometimes you want to keep row-level detail and still show a partition-level aggregate next to each row:

SELECT
    customer_id,
    payment_date,
    amount,
    ROUND(
        AVG(amount) OVER (
            PARTITION BY customer_id
            ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
        ),
        2
    ) AS customer_avg
FROM payment
WHERE customer_id IN (1, 2)
ORDER BY customer_id, payment_date;

This behaves a bit like GROUP BY customer_id, except rows are not collapsed. You still see every row, with the partition average attached to each one.

That pattern is useful when you want to compare a row against its wider context:

deviation from average;
share of total;
comparison with a partition maximum or minimum.

The main trap: `ROWS` and `RANGE` can produce different running totals

Suppose you have multiple rows with the same amount.

Compare these two expressions:

SELECT
    customer_id,
    amount,
    SUM(amount) OVER (
        ORDER BY amount
        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS sum_rows,
    SUM(amount) OVER (
        ORDER BY amount
        RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS sum_range
FROM payment
WHERE customer_id IN (1, 2, 3)
ORDER BY amount;

If amount = 11.99 appears multiple times, the behavior changes:

ROWS counts one physical row at a time;
RANGE includes all rows with the same amount together.

That is why a running total based on RANGE can jump several rows at once when there are duplicates in the ordering column.

This is one of the most common sources of confusion I see with window functions. The query is valid. The database is right. The expectation was wrong.

When I use `ROWS` vs `RANGE`

My rule of thumb is simple.

Use ROWS when you want:

row-by-row running totals;
moving averages based on a fixed number of rows;
predictable incremental behavior;
analytics where each physical row matters separately.

Use RANGE when you want:

calculations based on logical value ranges;
tied ORDER BY values to be treated together;
behavior tied to the ordering value itself rather than row count.

Use GROUPS when the right mental model is “peer groups as units.”

If I am not sure, I almost always start with ROWS. It is the most predictable option.

Named windows

When the same window definition is reused several times in one query, things get noisy fast. That is where the WINDOW clause helps:

SELECT
    customer_id,
    payment_date,
    amount,
    SUM(amount)   OVER w AS running_total,
    AVG(amount)   OVER w AS running_avg,
    COUNT(amount) OVER w AS payment_count
FROM payment
WHERE customer_id = 1
WINDOW w AS (
    PARTITION BY customer_id
    ORDER BY payment_date
    ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
)
ORDER BY payment_date;

Why I like this approach:

less duplication;
lower chance of mistakes;
easier maintenance;
the logic of the window lives in one place.

If a query contains several window functions, named windows usually make it much easier to read.

A practical reporting pattern: daily sales

One of the most useful patterns for reporting and dashboards looks like this:

SELECT
    DATE(payment_date) AS payment_day,
    SUM(amount) AS daily_total,
    SUM(SUM(amount)) OVER (
        ORDER BY DATE(payment_date)
        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS cumulative_total,
    ROUND(
        AVG(SUM(amount)) OVER (
            ORDER BY DATE(payment_date)
            ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
        ),
        2
    ) AS rolling_7day_avg
FROM payment
GROUP BY DATE(payment_date)
ORDER BY payment_day;

This gives you two very useful metrics immediately:

cumulative_total for the running total;
rolling_7day_avg for a 7-day moving average.

Notice the SUM(SUM(amount)) OVER (...) pattern: first we aggregate by day, then we apply a window function over the grouped result.

I like this example because it shows the practical value of frames very quickly. In one query, you get accumulation, smoothing, and a solid base for a chart or dashboard.

Where this topic kept breaking for me

If I reduce my own mistakes here to a short list, they usually came from three things:

mentally substituting “the whole partition” where only the current frame was actually used;
forgetting that RANGE does not behave like ROWS when ORDER BY values are duplicated;
relying too long on defaults instead of writing the frame explicitly.

Once I started asking one extra question for every window query, most of the confusion went away:

Which exact rows should be included in the calculation for the current row?

That question alone removes a lot of the magic.

What is worth remembering

A window frame is not about the partition itself and not about ordering by itself. It is specifically about the boundaries of rows included in the current calculation.

In short:

PARTITION BY splits data into partitions;
ORDER BY defines order inside a partition;
the frame defines which rows around the current row are included in the calculation.

The three most useful patterns to remember are:

running total:

ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW

full partition:

ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING

3-row sliding window:

ROWS BETWEEN 2 PRECEDING AND CURRENT ROW

And the most important trap is this:

if you have ORDER BY but no explicit frame, many databases will use RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW.

Which means duplicate ordering values can change the result in ways that are easy to miss.

Final thought

Window functions only became intuitive for me once I stopped thinking in terms of just partitions and ordering and started thinking in terms of frames.

If you want to write analytical SQL with confidence, it is worth building one habit:

do not rely on the default frame;
write it explicitly;
choose between ROWS and RANGE on purpose;
remember that ties in ORDER BY change frame behavior.

If I had to leave one practical takeaway from this entire article, it would be this:

When you write a window function, do not think only about PARTITION BY and ORDER BY. Ask one more question: which exact rows should participate in the calculation for the current row?

Once that answer is explicit, window queries become much more reliable and much easier to reason about.

If you want to experiment with ROWS, RANGE, and GROUPS directly, sqlize.online is the easiest place to test queries quickly. If you want a more structured way to study SQL through lessons and practice, I publish that work on sqltest.online.

Make Your Technical Tutorials Interactive with SQLize Embed

Slava Rozhnev — Tue, 20 Jan 2026 13:19:48 +0000

If you've ever written a SQL tutorial or database documentation, you know the struggle. You provide a beautiful code snippet, but for your readers to actually see it in action, they have to:

Copy the code.
Open their local terminal or a heavy IDE.
Set up a database schema.
Run the code.

Most readers won't do it. They just keep scrolling.

Today, I'm excited to introduce SQLize Embed—a lightweight, responsive, and powerful way to embed live SQL sandboxes directly into your blog, documentation, or educational site.

What is SQLize Embed?

SQLize Embed is a client-side library that transforms static <div> elements into fully functional SQL editors. Powered by the SQLize.online engine, it allows users to write and execute SQL against real database instances without leaving your page.

Key Features

20+ Database Engines: Supports everything from the classics like MySQL 8.0/9.3, PostgreSQL (14-18), and SQLite 3, to enterprise giants like MS SQL Server (2017-2025) and Oracle 23ai.
Ready-to-Use Datasets: Want to demo a JOIN? Use preloaded databases like Sakila (MySQL/MariaDB), OpenFlights, or AdventureWorks (MS SQL).
Modern Editor Experience: Powered by the Ace Editor, providing syntax highlighting, auto-indentation, and a professional coding feel.
Responsive & Lightweight: Works seamlessly on mobile and desktop.
Read-Only Mode: Perfect for strictly showing examples that you want users to run but not modify.

Getting Started in 30 Seconds

Adding a live SQL sandbox to your site is as easy as adding a YouTube video.

1. Include the Script

Add this script tag to your site's <head> or before the closing </body> tag:

<script src="https://sqlize.online/js/sqlize-embed.js"></script>

2. Add Your Sandbox

Create a div with the data-sqlize-editor attribute. Specify your preferred database version and initial code:

<div data-sqlize-editor data-sql-version="mysql80" code-rows="10">
-- Create a sample table
CREATE TABLE dev_to_fans (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(100)
);

-- Insert data
INSERT INTO dev_to_fans (username) VALUES ('awesome_dev'), ('sql_ninja');

-- Run it!
SELECT * FROM dev_to_fans;
</div>

Advanced Configuration

You can customize the appearance and behavior of the sandbox using simple HTML attributes:

Attribute	Description	Default
`data-sql-version`	The DB engine (e.g., `psql17`, `mssql2025`, `clickhouse`)	`mysql80`
`code-rows`	The height of the editor in lines	`12`
`result-rows`	The height of the result area	`12`
`data-read-only`	Set to `true` to disable editing	`false`

Use Cases

Interactive Learning: Build a "SQL 101" course where users solve challenges directly in the browser.
Documentation: Stop using screenshots of tables. Let users run DESCRIBE table themselves.
Technical Blogs: Show off complex PostgreSQL window functions or the new MariaDB Vector types with live examples.

Try the Live Demo

Check out the live documentation and various examples here:
👉 SQLize Embed Documentation

👉 SQLize Embed Showcase

Join the Community!

We are constantly adding support for new database versions (we already have MS SQL Server 2025!). If you have a specific database or dataset you'd like to see, let us know in the comments!

Happy coding! 💻

sql #database #webdev #tutorial #productivity #programming

Debunking the Myth: Is JOIN Always Faster Than Correlated Subqueries?

Slava Rozhnev — Tue, 11 Nov 2025 19:18:20 +0000

Hey there, fellow developers! If you've ever dabbled in SQL, you've probably heard the golden rule: "Never use correlated subqueries in SELECT—they're a recipe for N+1 disasters!" Instead, we're told to always opt for JOINs because they're set-based, efficient, and lightning-fast.

But is this rule set in stone? I decided to put it to the test across four popular database systems: MySQL 8.0, Oracle 23c, PostgreSQL 16, and SQLite 3.45. Spoiler alert: The results were eye-opening. Sometimes, the "bad" correlated subquery outperformed the "good" JOIN. Let's dive in and see why.

The Test Setup: Customers and Orders
To keep things fair, I used a simple schema with two tables:

customers: A small table with 25 rows of customer data.
orders: A larger table with 1,000 rows of orders, linked via a foreign key.
The goal? Count the number of orders per customer, including those with zero orders.

Here's the schema (using MySQL syntax for reference):

-- Customers table
CREATE TABLE customers (
    customer_id INT PRIMARY KEY,
    name VARCHAR(255) NOT NULL
);

-- Orders table
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    customer_id INT,
    order_date DATETIME,
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id) ON DELETE CASCADE
);

Data was populated with random values to simulate real-world scenarios.

The Two Queries: JOIN vs. Correlated Subquery
I compared two approaches to achieve the same result.

The "Good" Way – JOIN + GROUP BY This is the set-based, relational approach everyone loves:

SELECT 
    c.customer_id, 
    COUNT(o.order_id) AS orders_count
FROM 
    customers c
LEFT JOIN 
    orders o ON c.customer_id = o.customer_id
GROUP BY 
    c.customer_id;

Pros: Handles all customers, even those without orders.
Theory: One optimized operation to join and aggregate.

The "Bad" Way – Correlated Subquery This is the row-by-row method we're warned against:

SELECT 
    c.customer_id, 
    (SELECT COUNT(o.order_id) 
     FROM orders o 
     WHERE o.customer_id = c.customer_id) AS orders_count
FROM 
    customers c;

Pros: Also includes customers with zero orders.
Theory: Executes a subquery for each customer—classic N+1 problem.

Testing Across Databases: The Results
I ran both queries on online SQL testers (links provided below) and analyzed execution times and plans using EXPLAIN. Here's what happened.

MySQL 8.0: Subquery Wins!
Execution Times: Subquery ~14 ms vs. JOIN ~16 ms.
Why? The subquery triggered a Nested Loop plan with fast index lookups (25 quick searches). JOIN used Hash Join + Aggregate, which was overkill for small data.
Key Insight: With an index on orders.customer_id, the subquery wasn't N+1—it was efficient Nested Loops.
Test Link: MySQL Tester

Oracle 23c: Subquery Dominates!
Execution Times: Subquery ~2.4 ms vs. JOIN ~15 ms.
Why? Similar to MySQL—Nested Loop for subquery vs. Hash Join for JOIN. The subquery avoided heavy aggregation overhead.
Key Insight: Indexes are crucial; without them, Oracle falls back to full scans.
Test Link: Oracle Tester

PostgreSQL 16: JOIN Takes the Lead
Execution Times: JOIN ~0.6 ms vs. Subquery ~1.9 ms.
Why? PostgreSQL's optimizer rewrote the subquery into a JOIN-like plan, but the explicit JOIN was slightly faster. Subquery showed 25 sub-plan executions (mild N+1).
Key Insight: PostgreSQL is smart—indexes level the playing field.
Test Link: PostgreSQL Tester

SQLite 3.45: A Tie!
Execution Times: Both ~1 ms.
Why? Plans were nearly identical: SCAN on customers + SEARCH on orders via index. No N+1 effect.
Key Insight: SQLite's simplicity made both queries efficient; choose based on readability.
Test Link: SQLite Tester

Key Takeaways: No Silver Bullet
The "JOIN is always faster" myth crumbles because performance depends on:

Database Optimizer: PostgreSQL rewrites queries; MySQL/Oracle follow your syntax more literally.
Data Size: Small outer tables (like our 25 customers) favor Nested Loops; large ones benefit from Hash Joins.
Indexes: Without an index on orders.customer_id, subqueries tank. With it, they shine.
Bottom Line: Don't blindly follow rules. Always run EXPLAIN (or EXPLAIN ANALYZE) to see the actual execution plan. Test with your data!

What are your experiences with JOINs vs. subqueries? Drop a comment below!

This article is based on real testing and analysis. Links to testers are provided for you to verify the results.

SQL Tricks: Generate Calendar Table

Slava Rozhnev — Sat, 19 Jul 2025 19:34:49 +0000

Creating a "calendar table" or "date dimension" is a common task in SQL, especially for reporting, data warehousing, or when you need to perform calculations based on dates that might not exist in your actual data (e.g., finding days with no sales). While a full-fledged calendar table usually contains many attributes (day of week, week number, quarter, holiday flags, etc.), sometimes you just need a simple list of dates for a specific period, like the current month.

In this post, we'll explore how to dynamically generate a table containing all dates for the current month across different popular RDBMS dialects: MySQL, PostgreSQL, MS SQL Server, and Oracle. This approach avoids hardcoding dates and ensures your script always works for the current period.

Why generate a calendar table?
Before we dive into the code, let's briefly touch upon why this is useful:

Filling Gaps: If your transaction data only records days with activity, a calendar table can help you identify days with no activity (e.g., zero sales).
Time-Series Analysis: Essential for analyses that require a continuous timeline, even when data is sparse.
Simplifying Joins: You can join your data to a calendar table to easily group by specific date parts or filter by continuous date ranges.
Reporting: Providing a complete date range for reports, even if some dates have no associated data.

Let's look at the solutions for each database system.

MySQL

MySQL offers a few ways to generate series. We'll use a common table expression (CTE) combined with a recursive CTE or a numbers table approach to generate our dates.

WITH RECURSIVE dates AS (
    SELECT
        DATE_SUB(CURDATE(), INTERVAL DAYOFMONTH(CURDATE()) - 1 DAY) AS dt -- First day of current month
    UNION ALL
    SELECT
        DATE_ADD(dt, INTERVAL 1 DAY)
    FROM
        dates
    WHERE
        dt < LAST_DAY(CURDATE()) -- Last day of current month
)
SELECT
    dt AS calendar_date
FROM
    dates;

Explanation:

WITH RECURSIVE dates AS (...): Defines a recursive CTE named dates.
Anchor Member: SELECT DATE_SUB(CURDATE(), INTERVAL DAYOFMONTH(CURDATE()) - 1 DAY): This calculates the first day of the current month. CURDATE() gets the current date, DAYOFMONTH(CURDATE()) gets the day of the month (e.g., 15 for July 15th), and we subtract (day - 1) days to get to the 1st of the month.
Recursive Member: SELECT DATE_ADD(dt, INTERVAL 1 DAY) FROM dates WHERE dt < LAST_DAY(CURDATE()): This part adds one day to the previous date (dt) until it reaches the last day of the current month, which is obtained using LAST_DAY(CURDATE()).

Try this solution with SQLize.online

PostgreSQL

PostgreSQL has a very convenient generate_series() function which is perfect for this task.

SELECT
    GENERATE_SERIES(
        DATE_TRUNC('month', CURRENT_DATE), -- First day of current month
        (DATE_TRUNC('month', CURRENT_DATE) + INTERVAL '1 month' - INTERVAL '1 day')::date, -- Last day of current month
        '1 day'
    )::date AS calendar_date;

Explanation:

GENERATE_SERIES(start, stop, step): Generates a series of values.
DATE_TRUNC('month', CURRENT_DATE): Truncates the current date to the beginning of the month, giving us the first day.
(DATE_TRUNC('month', CURRENT_DATE) + INTERVAL '1 month' - INTERVAL '1 day'):📅 This calculates the last day of the current month. We go to the beginning of the next month (+ INTERVAL '1 month') and then subtract one day (- INTERVAL '1 day') to get the last day of the current month.
'1 day': Specifies that each step in the series should be one day.
:📅 Casts the resulting timestamp to a date type for a cleaner output.

Test tris code on SQLize.online

MS SQL Server

SQL Server offers multiple ways to generate sequences. Since SQL Server 2022, the GENERATE_SERIES function provides a straightforward method, similar to PostgreSQL. For earlier versions, or if you prefer, recursive CTEs are also a good option.

Using GENERATE_SERIES (SQL Server 2022+)

SELECT
    DATEADD(day, value, DATEADD(month, DATEDIFF(month, 0, GETDATE()), 0)) AS calendar_date
FROM
    GENERATE_SERIES(0, DAY(EOMONTH(GETDATE())) - 1);

Explanation:

GENERATE_SERIES(start, stop, step): This function generates a sequence of numbers from start to stop with increments of step. By default, step is 1 if omitted.
DATEADD(month, DATEDIFF(month, 0, GETDATE()), 0): This calculates the first day of the current month. This will be our base date.
DAY(EOMONTH(GETDATE())) - 1: EOMONTH(GETDATE()) returns the last day of the current month. DAY() extracts the day number (e.g., 31 for July 31st). Subtracting 1 gives us the maximum number to generate for our series (from 0 to days_in_month - 1). For example, if a month has 31 days, we want to generate numbers from 0 to 30.
DATEADD(day, value, ...): For each value generated by GENERATE_SERIES (which are 0, 1, 2, ... up to days_in_month - 1), we add that number of days to our first day of current month base date. This effectively generates each date of the month.

Try this SQL online

Using Recursive CTE (Older SQL Server Versions or Alternative)

WITH Dates AS (
    SELECT
        DATEADD(month, DATEDIFF(month, 0, GETDATE()), 0) AS dt -- First day of current month
    UNION ALL
    SELECT
        DATEADD(day, 1, dt)
    FROM
        Dates
    WHERE
        DATEPART(month, DATEADD(day, 1, dt)) = DATEPART(month, GETDATE())
)
SELECT
    dt AS calendar_date
FROM
    Dates
OPTION (MAXRECURSION 366); -- Set max recursion limit, 366 covers leap years

Explanation:

WITH Dates AS (...): Defines a recursive CTE named Dates.
Anchor Member: SELECT DATEADD(month, DATEDIFF(month, 0, GETDATE()), 0) AS dt: This is a common SQL Server idiom to get the first day of the current month.
DATEDIFF(month, 0, GETDATE()): Calculates the number of month boundaries crossed between 0 (which SQL Server treats as January 1, 1900) and GETDATE().
DATEADD(month, ..., 0): Adds that number of months to 0, effectively landing on the first day of the current month.
Recursive Member: SELECT DATEADD(day, 1, dt) FROM Dates WHERE DATEPART(month, DATEADD(day, 1, dt)) = DATEPART(month, GETDATE()): Adds one day to dt as long as the month of the next date is still the current month.
OPTION (MAXRECURSION 366): Important for recursive CTEs in SQL Server. It sets the maximum number of times the recursive part can execute. 366 is a safe number to cover all possible days in a year (including leap years).

Try legacy SQL Server code

Oracle

Oracle provides a powerful CONNECT BY LEVEL clause, often used for generating sequences.

SELECT
    TRUNC(SYSDATE, 'MM') + LEVEL - 1 AS calendar_date
FROM
    dual
CONNECT BY
    TRUNC(SYSDATE, 'MM') + LEVEL - 1 <= LAST_DAY(SYSDATE);

Explanation:

TRUNC(SYSDATE, 'MM'): Truncates the current date (SYSDATE) to the first day of the current month.
LEVEL: A pseudo-column in hierarchical queries that returns the current level in the hierarchy (starting from 1).
TRUNC(SYSDATE, 'MM') + LEVEL - 1: Generates successive dates starting from the first day of the month.
When LEVEL is 1, it's first_day_of_month + 1 - 1 = first_day_of_month.
When LEVEL is 2, it's first_day_of_month + 2 - 1 = first_day_of_month + 1 day.
FROM dual: dual is a dummy table in Oracle, often used for selecting pseudo-columns or evaluating expressions.
CONNECT BY TRUNC(SYSDATE, 'MM') + LEVEL - 1 <= LAST_DAY(SYSDATE): This clause acts as the loop condition. It continues generating rows as long as the generated date is less than or equal to the last day of the current month (LAST_DAY(SYSDATE)).

Oracle SQL playground online

Conclusion

As you can see, while the syntax differs across RDBMS, the core concept of generating a series of dates remains similar. With the addition of GENERATE_SERIES in SQL Server 2022, modern SQL versions are increasingly standardizing on easier ways to achieve this. Understanding these techniques is crucial for effective data manipulation and reporting in SQL. Choose the method that best suits your specific database environment and version.

I hope this was helpful! Feel free to leave a comment if you have any questions or alternative approaches.

SQLtest.online - the site where you can test your SQL skills

Slava Rozhnev — Sat, 17 Feb 2024 12:00:35 +0000

Hello friends! I'll tell you about my new project - SQLTest.online. This is a platform for those who are learning SQL and want to test their skills by solving practical problems.

The using of the site is very simple - select a problem from the list on the left and try to solve it! So far there are more then 220 questions on MySQL, several questions on Firebird. For tests, public databases Sakila (MySQL), Bookings (PostgreSQL) and Employee (Firebird) are used. In the future, I plan to expand both the list of available databases and the number of questions for each of them.

The table structure of the database relevant for each task is displayed on the right side of the screen and helps you in solving.

If you are at a loss with a solution, you can use the hint or run a query and see the result. Validation of a solution is performed in two stages: a basic check using regular expressions and then checking the result against the correct solution.

If you are interested in the project and decide to pass all the tests, you can log in to the site. Login is currently available via Google, Yandex and GitHub. When you log in to the site, no personal information is collected, only data about your progress in solving problems. However, even without registration, you get access to all functions of the site without restrictions!

So, Happy testing with SQLTest.online

If you find problems on the site, write about them below in the comments to the article.

Generate Date Series in popular Databases

Slava Rozhnev — Wed, 23 Aug 2023 20:43:15 +0000

In this post I want to answer to frequently asked question: How I can generate date series between to particular dates?

Generating a date series between two particular dates can be done using different methods depending on the relational database management system (RDBMS) you are using. I'll provide examples for a few popular RDBMS systems: MySQL, PostgreSQL, and Microsoft SQL Server.

Please note that the syntax might slightly differ based on the specific version of the RDBMS you're using, so you should consult the documentation for your specific version if you encounter any issues.

MySQL

Legacy MySQL (5.7.*)
The old MySQL doesn't have built-in functions to generate a date series, so you might need to use a temporary table or a numbers table. Here's an example using a numbers table approach:

CREATE TEMPORARY TABLE Numbers (n INT);
-- Insert numbers up to the desired range
INSERT INTO Numbers VALUES (0), (1), (2), ...;  

SELECT 
    DATE_ADD('start_date', INTERVAL n DAY) AS generated_date
FROM Numbers
WHERE 
    DATE_ADD('start_date', INTERVAL n DAY) <= 'end_date';

Just replace 'start_date' and 'end_date' with your desired start and end dates and try it on SQLize.online.

In Modern MySQL 8.0.*, you can use a Common Table Expression (CTE) to generate a date series between two particular dates. Here's how you can do it:

SET @start_date = '2022-01-01';
SET @end_date = '2022-01-31';

WITH RECURSIVE DateSeries AS (
    SELECT @start_date AS generated_date
    UNION ALL
    SELECT DATE_ADD(generated_date, INTERVAL 1 DAY)
    FROM DateSeries
    WHERE generated_date < @end_date
)
SELECT generated_date
FROM DateSeries;

Explanation:

The WITH RECURSIVE clause defines the CTE named DateSeries.
In the initial SELECT statement within the CTE, we set the anchor value to the start date.
In the recursive SELECT statement, we use the DATE_ADD function to increment the date by one day for each iteration.
The WHERE clause in the recursive SELECT statement ensures that the recursion continues until the generated date is less than the end date.
Finally, the outer SELECT statement selects all the generated dates from the CTE.

Remember that recursive queries can be resource-intensive, so use them cautiously and only when necessary. Try the query here

PostgreSQL

PostgreSQL has the generate_series function that makes this task easy:

SELECT generate_series('2022-01-01'::date, '2022-01-31'::date, '1 day') AS generated_date;

Replace 'start_date' and 'end_date' with your desired start and end dates.

Microsoft SQL Server

SQL Server also has a similar approach using the sys.dates system table and the DATEADD function:

DECLARE @start_date DATE = '2022-01-01'
DECLARE @end_date DATE = '2022-01-31'

SELECT TOP 
    (DATEDIFF(day, @start_date, @end_date) + 1)
    generated_date = DATEADD(day, ROW_NUMBER() OVER(ORDER BY a.object_id) - 1, @start_date)
FROM sys.all_objects a
CROSS JOIN sys.all_objects b;

Since SQL Server 2022 where implemented GENERATE_SERIES function you can use it for generate dates series too in next way:

SELECT 
    DATEADD(day, value, '2022-01-01') AS Date
FROM GENERATE_SERIES(0, DATEDIFF(day, '2022-01-01', '2022-01-31'))

Oracle

SELECT DATE '2022-01-01' + LEVEL - 1 AS generate_series
FROM dual
CONNECT BY LEVEL <= DATE '2022-01-31' - DATE '2022-01-01' + 1

Another cool method:

SELECT TRUNC (DATE '2023-01-01' + ROWNUM) dt
  FROM DUAL CONNECT BY ROWNUM < 31

If you know more methods to get date series in different RDBMS, please post in comments

Exploring PostgreSQL's EXCLUDE Operator: Advanced Data Constraints

Slava Rozhnev — Tue, 30 May 2023 22:05:45 +0000

Introduction

In the process of designing a database, as described in my previous article, I decided to utilize the EXCLUDE constraint to maintain data integrity. While contemplating this, I realized that the EXCLUDE operator deserves a dedicated article.

Introduction to the EXCLUDE Operator

PostgreSQL is renowned for its numerous powerful features, and one of them is the EXCLUDE operator. This operator allows you to create advanced constraints on sets of values within table columns. In this article, I want to delve into the EXCLUDE operator, provide examples of its usage, and help you understand how to leverage it to build flexible and efficient databases.

Similar to the UNIQUE constraint in PostgreSQL, the EXCLUDE operator is used to define constraints on sets of values within table columns. However, unlike UNIQUE, it enables you to specify rules that determine which values cannot coexist within a particular column or set of columns. The EXCLUDE operator is often used with GiST or SP-GiST index types to ensure query efficiency, although it can also be used with a regular B-Tree index.

Examples of Usage

A common example of utilizing EXCLUDE is applying a constraint on overlapping time intervals, such as movie screenings in a cinema.

CREATE TABLE events (
    id serial primary key,
    event_time tstzrange,
    constraint no_screening_time_overlap exclude using gist (
        event_time WITH &&
    )
);

INSERT INTO events (event_time) VALUES ('["2023-01-01 19:00:00", "2023-01-01 20:45:00"]');

In the above example, we create a table named "events" and insert a record with a time interval. You can check the SQL on SQLize.online. Afterwards, you can try inserting another row with an interval that overlaps with an existing one in the table. Most likely, it will result in an error. If you manage to succeed, let me know in the comments!

Similar to UNIQUE, the EXCLUDE constraint can be applied to a group of columns. For instance, you can use the "event_start" and "event_end" columns of type timestamp and restrict time overlaps. Here's an example:

CREATE TABLE events (
    event_id serial primary key,
    event_name VARCHAR(100) NOT NULL,
    event_start TIMESTAMPTZ NOT NULL,
    event_end TIMESTAMPTZ NOT NULL,
    EXCLUDE USING GIST (event_start WITH &&, event_end WITH &&)
);

Constraints on numeric ranges can also be imposed using EXCLUDE. Take a look at this example:

CREATE TABLE ranges (
    range_id serial primary key,
    start_value INTEGER NOT NULL,
    end_value INTEGER NOT NULL,
    EXCLUDE USING GIST (int4range(start_value, end_value, '[]') WITH &&)
);

In this example, the "ranges" table is created, which contains numeric ranges. The EXCLUDE operator with a GiST index specifies that the numeric ranges in the "start_value" and "end_value" columns cannot overlap.

Another significant application is constraining the intersection of geometric figures:

CREATE TABLE polygons (
    polygon_id serial primary key,
    polygon_data geometry(Polygon) NOT NULL,
    EXCLUDE USING GIST (polygon_data WITH &&)
);

Here, the "polygons" table is created, which stores information about polygons. The EXCLUDE operator with a GiST index ensures that geometric objects in the "polygon_data" column cannot intersect or be contained within each other.

In all the above examples, we utilized the EXCLUDE constraint based on a GiST index. However, for completeness, let's provide an example using an R-Tree:

CREATE TABLE users (
    user_id serial primary key,
    email VARCHAR(255) NOT NULL,
    EXCLUDE USING btree (lower(email) WITH =)
);

In this example, we nearly replicated the functionality of the UNIQUE constraint with a slight modification. Our uniqueness is now case-insensitive.

Conclusion

The EXCLUDE operator in PostgreSQL offers the ability to create advanced constraints on sets of values within table columns. It allows you to define rules that restrict combinations of values that cannot coexist. This is particularly useful for ensuring data integrity and performing complex checks at the database level.

In this article, we explored several examples of using the EXCLUDE operator, including constraints on overlapping time intervals, prohibition of intersecting geometric objects, and constraints on non-overlapping numeric ranges. The EXCLUDE operator is a powerful tool that can be employed to build flexible and efficient databases in PostgreSQL.

In your projects, utilize the EXCLUDE operator to create sophisticated constraints and ensure data integrity at the database level. This will help you maintain the structure and reliability of your database while optimizing its usage.

If you found this article helpful, you can show your support to the author.

MySQL 8.0: Invisible Columns

Slava Rozhnev — Tue, 16 May 2023 12:03:39 +0000

The Oracle company ported INVISIBLE COLUMN feature to it's little brother MySQL. Since version 8.0.23 the invisible column feature available for MySQL users.

Let's learn how it works!

You can create invisible column as regular when you create a table using INVISIBLE keyword:

CREATE TABLE test_table (
  a INT,
  b DATE INVISIBLE
) ENGINE = InnoDB;

or add new column to an exists table by ALTER TABLE command:

ALTER TABLE test_table ADD COLUMN c INT INVISIBLE;

When a column exists you can change its visibility using CHANGE, MODIFY or ALTER COLUMN command as you can see below:

ALTER TABLE test_table CHANGE COLUMN b b DATE VISIBLE;
ALTER TABLE test_table MODIFY COLUMN b DATE INVISIBLE;
ALTER TABLE test_table ALTER COLUMN c SET VISIBLE;

When you fetch table structure you will see all columns, but part of them will be marked by INVISIBLE flag:

SHOW COLUMNS FROM test_table;
SHOW CREATE TABLE test_table;

So you see, the invisible column manipulation pretty simple. Now look how the visibility affects DML.

First, when you try to select all columns using SELECT *, the invisible columns are not appears. So if you need to see they, you must to know the column name and select it by its name. Look below SQL code examples:

TABLE test_table; SELECT * FROM test_table; -- column hidden

SELECT a, b, c FROM test_table; -- column visible

Same way, when you need to insert data to invisible column you must call it by name:

INSERT INTO test_table VALUES (1, now(), 33); -- Error
INSERT INTO test_table () VALUES (1, now(), 33); -- Error too

INSERT INTO test_table VALUES (1, 22); -- NULL inserted
INSERT INTO test_table (a, b, c) VALUES (1, now(), 33); -- all values

Where you can use this feature? First - security - you can use invisible column for hide some column from DB users with low permissions. Second - when you use generated column you can prevent insert data to such column doing it invisible.
Look next example:

CREATE TABLE test_table (
  a INT,
  b INT
) ENGINE = InnoDB;

INSERT INTO test_table VALUES (1, 2), (2, 3), (3, 4);

ALTER TABLE test_table ADD COLUMN a_b_sum INT AS (a + b);

SELECT * FROM test_table;

In above example we added generated column to our test_table but this change can break our insert query. What we can do in this case? Right - use invisible column.

ALTER TABLE test_table ALTER COLUMN a_b_sum SET INVISIBLE;

INSERT INTO test_table VALUES (5, 7), (2, 9), (2, 3);

SELECT a, b, a_b_sum FROM test_table;

Here you can run SQL queries online and test this feature.

So, this is all about this feature. If you think about more use-cases please share it in comments.