Detailed examples of tutorials on the use of join operations in Mysql

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

Types 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 internal union

• The default JOINs are INNER JOIN

• CROSS JOIN is grammatically equivalent to 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 the columns of java There are still java1 and java2 records, and all columns of the mysql table are 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 has no counterpart in

other

tables, you can use this method to find records in such tables:

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 People here, obviously the people 'java1' and 'java2' meet the requirements.

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 it is mysql The table holds 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 Used to name a series of columns, which must exist in both tables at the same time

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

The result is returned

+-------+------+
| 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 when we write such

query

in the future, we Don’t forget to write a few more parentheses, at least this way you can avoid a lot of mistakes[Related recommendations]

Mysql free video tutorial

2.

What are the common databases in China? Introduction to various databases

3.

17 points for MySQL performance optimization

4.

Mysql diagnosis startup problems and detailed explanation of viewing log files

5.

Detailed explanation of backup and maintenance of MySQL database

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