Sharing examples of join operations in Mysql

This article mainly introduces the relevant information of Mysql join operation. Friends who need it can refer to it. I hope it can help everyone.

Type of join

1． Inner join: A join that forms a record set by combining those records whose fields in the two tables have a join relationship and that match the join relationship.

2. Outer join: divided into outer left join and outer right join.

Case background

create table java (name varchar(255));
insert into java values ('java1'),('java2'),('blue'); 
create table mysql (name varchar(255));
insert into mysql values ('mysql1'),('mysql2'),('blue');

Inner join

select * from java,mysql where java.name=mysql.name;
SELECT * FROM java JOIN mysql ON java.name=mysql.name;
SELECT * FROM java INNER JOIN mysql ON java.name=mysql.name;
SELECT * FROM java CROSS JOIN mysql ON java.name=mysql.name;
SELECT * FROM java STRAIGHT_JOIN mysql ON java.name=mysql.name;

These four statements are all inner joins, and the returned results are all

+------+------+
| name | name |
+------+------+
| blue | blue |
+------+------+

• Each comma in the table_reference entry is regarded as equivalent to an inner union

• The default JOINs are INNER JOIN

• CROSS JOIN syntax It says that it is the same as INNER JOIN

• STRAIGHT_JOIN is the same as JOIN. Except for one difference, the left table will be read before the right table. STRAIGH_JOIN can be used in situations where the join optimizer sorts the tables in the wrong order.

The syntax of inner join is as follows:

join_table:
 table_reference [INNER | CROSS] JOIN table_factor [join_condition]
 | table_reference STRAIGHT_JOIN table_factor
 | table_reference STRAIGHT_JOIN table_factor ON condition

Outer join

Left join

SELECT * FROM java LEFT JOIN mysql ON java.name=mysql.name;

The result is

+-------+------+
| name | name |
+-------+------+
| java1 | NULL |
| java2 | NULL |
| blue | blue |
+-------+------+

So from the above results, it can be seen that because the names of the java1 and java2 records in the Java table do not have corresponding names in the MySQL table, they are empty, but all columns of java still have java1 and java2 records, and all columns of the mysql table is NULL. The remaining blue record is the result of the internal connection between the java table and the mysql table.

If there are no matching records for the right table in the ON or USING section of the LEFT JOIN, a row with all columns set to NULL is used for the right table. If a table does not have a corresponding part in other tables, you can use this method to find records in this table:

SELECT * FROM java LEFT JOIN mysql ON java.name=mysql.name WHERE mysql.name IS NULL;

This sql finds people in java, but not in mysql, which is obvious here Yes personnel 'java1' and 'java2' meet the requirement.

Right join

SELECT * FROM java RIGHT JOIN mysql ON java.name=mysql.name;

The return result is

+------+--------+
| name | name |
+------+--------+
| NULL | mysql1 |
| NULL | mysql2 |
| blue | blue |
+------+--------+

The results of right join and left join are similar, except this time the mysql table saves all result sets.

Syntax of outer join

join_table:| table_reference LEFT [OUTER] JOIN table_reference join_condition
 | table_reference NATURAL [LEFT [OUTER]] JOIN table_factor
 | table_reference RIGHT [OUTER] JOIN table_reference join_condition
 | table_reference NATURAL [RIGHT [OUTER]] JOIN table_factor

USING(column_list) clause

is used to name a series of columns, which must exist in both tables

SELECT java.*,mysql.* FROM java LEFT JOIN mysql USING (name);

Result return

+-------+------+
| name | name |
+-------+------+
| java1 | NULL |
| java2 | NULL |
| blue | blue |
+-------+------+

The order of operations of the join

SELECT * FROM t1 LEFT JOIN (t2, t3, t4) ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c);
--相当于
SELECT * FROM t1 LEFT JOIN (t2 CROSS JOIN t3 CROSS JOIN t4) ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c)

The impact of brackets on the order of join

SELECT t1.id,t2.id,t3.id FROM t1,t2 LEFT JOIN t3 ON (t3.id=t1.id) WHERE t1.id=t2.id;
--实际上这么执行
SELECT t1.id,t2.id,t3.id FROM t1,( t2 LEFT JOIN t3 ON (t3.id=t1.id) ) WHERE t1.id=t2.id;
--应该这么写
SELECT t1.id,t2.id,t3.id FROM (t1,t2) LEFT JOIN t3 ON (t3.id=t1.id) WHERE t1.id=t2.id;

The brackets are very important here, so in the future When writing such a query, we should not forget to write a few more parentheses, at least this can avoid many errors.

Related recommendations:

Detailed examples of the difference between split and join in javaScript

Sharing of usage examples of Join in MySQL

How to use JOIN USING in sql to simplify JOIN ON examples

The above is the detailed content of Sharing examples of join operations in Mysql. For more information, please follow other related articles on the PHP Chinese website!