Vous êtes sur la page 1sur 9

11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.

com

MS SQL SQL Scripts & Database


Oracle DB2 Access MySQL PostgreSQL Sybase PHP Tips
SQL Etc Samples Forum
Database Journal |DBA Support |SQLCourse  
 » Database Journal |SQLCourse2
Home  
 » Database Articles Featured Database Articles  
 » Database Tutorials  
 MS SQL MySQL
 Oracle
 DB2 Posted Aug 28, 2009
 MS Access
 MySQL Fetching Data from Multiple Tables
 » RESOURCES
 SQL Scripts & using Joins
Samples
 Tips By Rob Gravelle
 » Database Forum Normalization is almost universally applied to relational databases such as
 » Slideshows MySQL in order to optimize tables for general­purpose querying and to rid
 » Sitemap them of certain undesirable characteristics that could lead to a loss of data
integrity. Doing so tends to promote better accuracy of queries, but it also
Free Newsletters: leads to queries that take a little more work to develop, as the data may be
spread amongst several tables. In today’s article, we’ll learn how to fetch data
Enter your Email Address from multiple tables by using joins.

Two Syntaxes
News Via RSS Feed There are two accepted syntax styles for writing joins: ANSI­style joins and
theta­style joins. ANSI syntax uses the JOIN and ON keywords, as in the
following example:

SELECT  field1,  
  field2,  
FROM   my_table   t1 
JOIN  my_other_table  t2 
ON  t1.primary_id_field = t2.foreign_key_id_field 
WHERE  t1.lastname    = 'Smith'; 

The JOIN keyword is used to separate the names of the tables being joined,
and the ON clause contains the relation showing which column is being used
as the join key.

In theta­style syntax, the table joins are simply added to the WHERE clause:

SELECT  field1,  
  field2,  
FROM   my_table   t1, 
  My_other_table  t2 
WHERE  t1.primary_id_field = t2.foreign_key_id_field 
AND  t1.lastname    = 'Smith'; 

MySQL also supports a nonstandard extension of the ANSI syntax that can be
used as a sort of shorthand for when the join column has the same name in

https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 1/9
11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.com
both joined tables:

SELECT  field1,  
  field2,  
FROM   my_table   t1 
JOIN  my_other_table  t2 
USING  (t1.id_field) 
WHERE  t1.lastname    = 'Smith'; 

So Which Syntax is Best?
The ANSI syntax is generally preferable to theta style because it’s usually
easier to read and understand, particularly when writing joins involving
numerous tables. There are also some types of joins that can’t be written using
theta­style notation in MySQL.

Join Types

In order to join tables together, there has to be some common data that allow
those tables to be connected in some meaningful way. Although it’s possible
to have more than one common column between two tables, most often, the
join key will be the primary key of one table and a foreign key in the other.

To illustrate, we’ll perform queries against the following sample tables:

manufacturer model

id description id *manufacturer_id description

1 ACURA 1 ACURA INTEGRA

2 ALFA ROMEO 2 ACURA CL

3 ACURA LEGEND
3 ASUNA

4 ACURA RL
4 AUDI

5 ACURA NSX
5 BMW

6 ACURA TL
6 BUICK

7 ACURA VIGOR
7 CADILLAC

8 ACURA EL
8 CHEVROLET

9 ASUNA SEDAN
9 CHRYSLER

10 ASUNA HATCHBACK
10 DAEWOO
11 ACURA NSX­T
https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 2/9
11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.com

manufacturer
12 ALFA ROMEO SEDAN LS

id description
13 ALFA ROMEO SPIDER

11 DODGE
14 AUDI A4

12 EAGLE
15 AUDI A6

13 FORD 16 AUDI A8

14 GEO 17 AUDI S4

15 GMC 18 AUDI S6

16 HONDA 19 AUDI 90 SERIES

17 HYUNDAI 20 AUDI CABRIOLET

18 INFINITI 21 AUDI 100 SERIES

19 ISUZU 22 AUDI V8 QUATTRO

20 JAGUAR 23 BMW 318

21 LADA           24 BMW 323

25 BMW 328
22 LEXUS

26 BMW M3
23 LINCOLN

27 BMW 320
24 MAZDA

28 BMW 325
25 MERCEDES­
BENZ
29 BMW Z3 ROADSTER

26 MERCURY
ROADSTER M
30 BMW 3.2
27 NISSAN

31 BMW 528

https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 3/9
11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.com

32 BMW 540
manufacturer

33 BMW 525
id description

34 BMW 530
28 OLDSMOBILE
35 BMW M5
29 PLYMOUTH
36 BMW 535
30 PONTIAC
37 BMW 740
31 PORSCHE
38 BMW 750
32 SAAB
39 BMW

33 SATURN
40 BMW 840

34 SUBARU
41 BMW 850

35 SUZUKI
42 (NULL) Custom

36 TOYOTA

37 VOLKSWAGEN

38 VOLVO

39 JEEP

40 LAND ROVER

41 (NULL)

42 New Car Co

*Note: In a normalized database, the Manufacturer ID would be stored
in the Models table. Here, I included the full description to better
illustrate which manufacturers are associated with which models.

The first table contains automobile manufacturers; the second, some models
that are built by the first several auto manufacturers. The common data
between the two tables is the manufacturer, which is linked by manufacturer
ID.

https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 4/9
11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.com

Now we’ll extract some data from the tables, using different join types in
ANSI syntax.

Inner Join
An inner join is defined as a join in which unmatched rows from either table
are not to be returned. In other words, the rows must match in both tables in
order to be included in the result set.

SELECT    t1.description AS 'Manufacturer',  
    t2.description AS 'Model' 
FROM     manufacturer   t1
INNER JOIN  model    t2
ON    t1.id = t2.manufacturer_id 
WHERE    t1.description = 'ACURA'; 

The "INNER" keyword is not required, but it is considered good practice to
include it.

Typing the query above in the MySQL Command Line Client produces the
following:

mysql> SELECT           t1.description AS 'Manufacturer', 
    ‐>                  t2.description AS 'Model' 
    ‐> FROM             manufacturer    t1 
    ‐> INNER JOIN       model           t2 
    ‐> ON               t1.id = t2.manufacturer_id 
    ‐> WHERE            t1.description = 'ACURA'; 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐+ 
| Manufacturer | Model   | 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐+ 
| ACURA        | INTEGRA | 
| ACURA        | CL      | 
| ACURA        | LEGEND  | 
| ACURA        | RL      | 
| ACURA        | NSX     | 
| ACURA        | TL      | 
| ACURA        | VIGOR   | 
| ACURA        | EL      | 
| ACURA        | NSX‐T   | 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐+ 
9 rows in set (0.00 sec) 

Outer Join

Outer joins will return records in one table that aren’t matched in another.
Outer joins can be further divided into the two types of left and right. In a left
outer join, all records from the first (left­hand) table in a join that meet any
conditions set in the WHERE clause are returned, whether or not there’s a
match in the second (right­hand) table:

mysql> SELECT           t1.description AS 'Manufacturer', 
    ‐>                  t2.description AS 'Model' 
    ‐> FROM             manufacturer   t1 
    ‐> LEFT JOIN        model          t2 
    ‐> ON            t1.id = t2.manufacturer_id 
    ‐> WHERE    t1.description = 'New Car Co'; 

+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ 
| Manufacturer | Model          | 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ 
| New Car Co   | (NULL)         | 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ 
19 rows in set (0.00 sec) 

The ‘New Car Co’ is returned even though there are no associated models in
the model table.

https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 5/9
11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.com

Similar to the left outer join, a right outer join returns all records from the
second (right­hand) table in a join that meet any conditions set in the WHERE
clause, whether or not there’s a match in the first (left­hand) table:

mysql> SELECT           t1.description AS 'Manufacturer', 
    ‐>                  t2.description AS 'Model' 
    ‐> FROM             manufacturer    t1 
    ‐> RIGHT JOIN       model           t2 
    ‐> ON               t1.id = t2.manufacturer_id 
    ‐> WHERE    t2.description = 'Custom'; 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐+ 
| Manufacturer | Model  | 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐+ 
| (NULL)       | Custom | 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐+ 
1 row in set (0.00 sec) 

The ‘Custom’ model is returned even though there is no associated
manufacturer.

Cross­join
The cross­join, also referred to as a Cartesian product, returns all the rows in
all the tables listed in the query.  Each row in the first table is paired with all
the rows in the second table.  This happens when there is no relationship
defined between the two tables. 

Note that, most of the time, we do not want a Cartesian join, and we end up
with one because we failed to provide a filter on the join.  Result sets can get
large quickly because the amount of data in the select is the number of rows in
Table A multiplied by the number of rows in Table B. If you have more than
two tables this multiplies at an exponential rate.

If we actually want a Cartesian join, then we should use the ANSI cross join
to tell others reading the script that we actually wanted a Cartesian join. So
why would we want one? One reason might be to produce all the
combinations of 1, 2 and 3, which could be used as part of a password or ID
generation process:

numbers

num

mysql> SELECT CONCAT(   CAST(t1.num AS CHAR), 
    ‐>                  CAST(t2.num AS CHAR)) AS combinations 
    ‐> FROM numbers t1, numbers t2; 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ 
| combinations | 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ 
| 11           | 
| 21           | 
| 31           | 
| 12           | 
| 22           | 

https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 6/9
11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.com
| 32           | 
| 13           | 
| 23           | 
| 33           | 
+‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ 
9 rows in set (0.00 sec) 

Now you’ve got every permutation of number combinations for two digits!

Knowing how to link tables is of great assistance in extracting data from
normalized databases, but it may not always be enough. There will be times
that no combination of joins will suffice to properly filter the data. In those
cases, it may be necessary to use temporary tables. We’ll be looking at those
in the next article.

» See All Articles by Columnist Rob Gravelle

MySQL Archives

9 Comments (click to add your comment)
By subhash   April 16 2016 14:17 UTC

how ..i can fetch the data from two diffrent table in one output table .........
Reply to this comment
By NDABAHARIYE Jean Aime   February 12 2016 19:07
UTC

The codes that are providing to us, are very crucial for us. Once again thank
you so much
Reply to this comment
By Ali Sajjad   March 29 2015 10:02 UTC

I have one question, what, if i have 2 tables in my mysqli database, and i want
to fetch all data in one output table?
Reply to this comment
By king   March 23 2015 11:54 UTC

goood qu
Reply to this comment
By umadevi   January 31 2015 11:30 UTC

its very usefull for devlopers
Reply to this comment
By Niraja   July 11 2015 05:50 UTC

i need how to fetch data from different table of perticular name in
mysql..whatever contents in the different tables under this name all are
showing ....

By Arun   September 26 2012 04:36 UTC

Thanks it very interesting.
Reply to this comment
By Gopal Aggarwal   June 22 2012 06:57 UTC

Thank you for the detailed and easy­to­understand article.
Reply to this comment
By Omar   September 10 2009 20:46 UTC

Thanks, very interesting
Reply to this comment

https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 7/9
11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.com

Comment and Contribute

 Your name/nickname

 Your email

 Subject

(Maximum characters: 1200). You have  1200  characters left.

I'm not a robot


reCAPTCHA
Privacy - Terms

Submit Your Comment  

 
Latest Forum Threads
MySQL Forum
Topic By Replies Updated
August
MySQL in high availability and
28th,
transction secure banking klamor 1
10:24
application
AM
August
28th,
MySQL rollback UAL225 1
10:15
AM
July
26th,
Browsing a DB file that uses MySql finleytech 1
10:51
AM
June
php cookie won't pass variable to 22nd,
ITdevGirl 0
next page 12:13
PM

 
 
 
 
 

https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 8/9
11/4/2018 Fetching Data from Multiple Tables using Joins — DatabaseJournal.com

An eWEEK Property

Terms of Service | Licensing & Reprints | About Us | Privacy Policy | Contact Us | Advertise
Copyright 2018 QuinStreet Inc. All Rights Reserved.

https://www.databasejournal.com/features/mysql/article.php/3835506/Fetching­Data­from­Multiple­Tables­using­Joins.htm 9/9