How table joining really work in Mysql? - mysql

Question

For years, I understood that when tables are joined, one row from primary table is joined to a row in target table after applying conditions I.e the query results will <= rows in the primary table. But I have seen where one row in primary table can be joined multiple times of the conditions allow. e.g the query below's count function would not work without duplicate rows form primary table
SELECT node.name, (COUNT(parent.name) - 1) AS depth
FROM nested_category AS node,
nested_category AS parent
WHERE node.lft BETWEEN parent.lft AND parent.rgt
GROUP BY node.name
ORDER BY node.lft;
Which produces this result
+----------------------+-------+
| name | depth |
+----------------------+-------+
| ELECTRONICS | 0 |
| TELEVISIONS | 1 |
| TUBE | 2 |
| LCD | 2 |
| PLASMA | 2 |
| PORTABLE ELECTRONICS | 1 |
| MP3 PLAYERS | 2 |
| FLASH | 3 |
| CD PLAYERS | 2 |
| 2 WAY RADIOS | 2 |
+----------------------+-------+
I know I may be asking something really basic, but how exactly are rows joined together in the most simplest joins possible, does mysql take steps like when regex engine is executing pattern against string?

Answer 1

"How" joins are implemented is actually not important. SQL is a descriptive language, not a procedural language. The query engine can decide the "how". The query is describing the "what".
The conceptual definition of an inner join is rather simple. It is the Cartesian product of two sets that meets the conditions of the on and where clauses.
Most people don't think in terms of Cartesian products. A nested loop is equivalent. The logic is something like this:
for each row1 in table1
for each row2 in table2
output row1 || row2 if the on/where conditions are true
Outer joins extend this concept, allowing rows from one or both tables to be in the result set even when the on/where conditions are not true.
There is no concept whatsoever that about "query results will <= rows in the primary table." With some data structures -- notably a fact table with dimension tables joined in -- you will get that behavior. However, that is because the data model is designed for this purpose, not because SQL works that way.

Answer 2

My two cents. I agree that "how" is not important since SQL is a descriptive language. Well... it's not important until your queries become slow as hell (my experience) when the system is successful and the database grows (a lot).
If you need to find out why a SQL is slow or unresponsive you'll need to understand how the database works under the hood. There are multiple strategies databases use to JOIN tables. Commonly (not a complete list):
Nested Loop Join "NLJ": this is the one you mention.
Merge Join: joining tables "side by side".
Hash Join: hashing one table and then perform a scan on the other.
N-Ary Join: similar to NLJ but with more than two tables at once.
Depending on the size of the tables, column statistics, selectivity of your filter (where) your database can use one or the other. It can even change over time if column statistics & value distributions change.
If you want to learn what those strategies are, and when each one is convenient, you'll can start using
EXPLAIN <sql>
To see what strategy MySQL is using for your particular query. Then you can read about database theory to understand the details under the hood.