Sql statement ေတြဘက္ကိုေတာ့ မလွည့္ျဖစ္တာ ေတာ္ေတာ္ၾကာသြားျပီ။ ကြၽန္ေတာ္လည္း ေရးခ်င္တာေတြကေတာ့ အမ်ားၾကီး အခ်ိန္ကမရွိဘူးျဖစ္ေနတာနဲ႔ ေရွ႕မဆက္နိုင္ဘူးျဖစ္ေနတာ။ ဘာဘဲျဖစ္ျဖစ္ ရတဲ႔အခ်ိန္ေလးလုျပီး ကြၽန္ေတာ္သိသေလာက္ေတာ့ ထပ္ေရးေနဦးမွာမို႔ အားေပးၾကပါဦးဗ်ာ။ ကဲ… ကြၽန္ေတာ္တို႔ select statement ကို ေျပာလက္စ ဆက္ပါဦးမယ္။ table တစ္ခုထဲက data ကို ထုတ္ၾကည့္တာကိုေတာ့ နားလည္ေလာက္ျပီထင္ပါတယ္။ အခု ကြၽန္ေတာ္တို႔ တစ္ခုထက္ပိုတဲ႔ table ေတြထဲက data ေတြကို ထုတ္ၾကည့္ရေအာင္။ ဥပမာဗ်ာ… item table ထဲက record အားလံုးျပမယ္ဆိုပါေတာ့။ ဒါေပမယ့္ categoryid အစား categoryname ကိုျပခ်င္တယ္ဆိုရင္၊ item table နဲ႔ category table ၂ ခုကို ခ်ိတ္ရေတာ့မွာပါ။ ဟုတ္ျပီ… ဒါဆိုရင္ table ေတြ ခ်ိတ္ဖို႔အတြက္ ဘာေတြလိုလဲ… ?

ဟုတ္ကဲ႔ table တစ္ခုနဲ႔ တစ္ခုခ်ိတ္ဆက္တာကို join လုပ္တယ္လို႔ ေခၚပါတယ္။ join နည္း ၃ မ်ိဳးရွိပါတယ္။

၁) cross join

Cross join ကေတာ့ table ၂ ခုကို comer(,) ခံျပီး join တာပါ။ ဒီလိုမ်ိဳးပါ

select item.*, category.categoryName
from item, category

result

cross join လို႔ ဆိုတဲ႔ အတိုင္းပါပဲ။ ဒီပံုစံက table ၂ ခုကို ေျမွာက္လို႔ရတဲ႔ အတိုင္း result ထြက္ပါတယ္။ item ထဲမွာက record ၆ ေၾကာင္း၊ category ထဲမွာက record ၅ ေၾကာင္း ရွိပါတယ္။ ဒါေၾကာင့္ အေပၚက query ကို run လိုက္ရင္ record စုစုေပါင္း အေၾကာင္း ၃၀ ထြက္ပါလိမ့္မယ္။ item table ထဲက record ၁ေၾကာင္းစီ အတြက္ category table ထဲမွာ record ရွိသေလာက္ကို ထုတ္ျပသြားတာပါ။ ကြၽန္ေတာ္က ့ အကုန္မထုတ္ပဲ item table ထဲမွာ ပါတဲ႔ categoryID နဲ႔ category table ထဲမွာပါတဲ႔ categoryID တူတဲ႔ record ေတြပဲ ထုတ္ျပခ်င္တယ္ဆိုရင္ေတာ့ ထြက္လာတဲ႔ result ကို condition ျပန္စစ္ဖို႔ လိုပါတယ္။ ဒါေၾကာင့္ ကြၽန္ေတာ္တို႔ where ကို သံုးျပီး အခုလို ေရးရပါမယ္။

select item.*, category.categoryName
from item, category where item.categoryID = category.categoryID

result

၂) inner join
Inner join က cross join ကို where ထည့္ထားတဲ႔ ပံုစံနဲ႔ တူပါတယ္။ table ၂ ခုကို join ဖို႔အတြက္ On keyword ကိုသံုးပါတယ္။ ဒီလိုမ်ိဳးပါ..

select item.*, category.categoryName
from item inner join category
on item.categoryID = category.categoryID

result

inner join နဲ႔ေရးထားတဲ႔အတြက္ item table ထဲက categoryID က category table ထဲမွာ ရွိမေနဘူးဆိုရင္ အဲဒီ record ကို ထုတ္ျပေပးမွာမဟုတ္ပါဘူး။ ဟုတ္ျပီ တစ္ခါတေလမွာ ကြၽန္ေတာ္က item table ထဲက အားလံုးထုတ္ျပခ်င္တယ္၊ category table ထဲမွာ ရွိရင္ category name ျပျပီး၊ မရွိရင္ေတာ့ null ပဲေပၚလာခ်င္တယ္ဆိုရင္။ တနည္းအားျဖင့္ table တခုခုကို မူတည္ျပီး ျပခ်င္တယ္ဆိုရင္ ကြၽန္ေတာ္တို႔ inner join ကိုသံုးလို႔ မရေတာ့ပါဘူး။ ဒီအခါမွာ outer join ကိုသံုးရေတာ့မွာပါ။

၃) outer join
Outer join ကို ၂ ပိုင္းထပ္ခြဲနိုင္ပါတယ္။ Left outer join နဲ႔ Right outer join ပါ။ join keyword ရဲ႕ ဘယ္ဖက္က table ကို အကုန္ျပမယ္ဆိုရင္ left join နဲ႔ ေရးရျပီး။ join keyword ရဲ႕ ညာဖက္က table ကို အကုန္ျပခ်င္ရင္ေတာ့ right join နဲ႔ ေရးပါမယ္။

select item.*, category.categoryName
from item left join category
on item.categoryID = category.categoryID

result

select item.*, category.categoryName
from item right join category
on item.categoryID = category.categoryID

result

left join လို႔ေရးေရး left outer join လို႔ပဲ ေရးေရး တူတူပါပဲ။ right join နဲ႔ right outer join လည္း တူတယ္ေနာ္။ ေနာက္ဆံုး query result မွာ null ေတြထြက္လာတာ ေတြ႔ရတယ္ေနာ္၊ ဘာလို႔လဲဆိုေတာ့ category table ကို မူတည္ျပီး ယူလိုက္ေတာ့ item table ထဲမွာ မရွိတာေတြအတြက္ null ေတြထြက္လာတာပါ။

Boa noite pessoal!

Navegando pela internet, me deparei com um ótimo guia visual sobre os JOINs. Como o próprio autor do guia visual disse “As coisas parecem fazer sentido com imagens. Eu olhei pela internet por uma boa representação gráfica dos SQL JOINs, mas não pude encontrar nada que me agradasse.” (tradução livre), concordo com o autor, pois muitos exemplos pela internet complicam mais do que explicam como funcionam os JOINs, mas o guia que ele desenvolveu ficou muito bom.

Alguns vão achar este tópico um pouco “básico” em comparação aos que tenho escrito, mas eu e muitas pessoas que indiquei o guia inglês acharam este guia muito interessante, e com este post estarei “traduzindo” o guia, esperando que seja de utilidade didática e até mesmo pessoal para vocês. Principalmente para que aprendamos como expressar melhor conceitos para nós são tão simples, mas que muitas vezes não sabemos explicar de uma forma adequada.

Irei abordadar neste post sete diferentes formas de retornar dados de duas tabelas relacionadas, mas além destes existem outros JOINS. Os JOINs demonstrados serão os seguintes:

1. INNER JOIN
2. LEFT JOIN
3. RIGHT JOIN
4. OUTER JOIN
5. LEFT JOIN “excluindo” INNER JOIN
6. RIGHT JOIN “excluindo” INNER JOIN
7. OUTER JOIN “excluindo” INNER JOIN

Obs.: Os JOINs 5, 6 e 7 são na verdade variações dos anteriores, mas ainda podem ser considerados JOINs, devido aos seus comportamentos.

INNER JOIN

Este é simples, o mais entendível e o mais comum. Esta consulta retornará todos os registros da tabela esquerda (tabela A) que têm correspondência com a tabela direita (tabela B). Podemos escrever este JOIN da seguinte forma:

LEFT JOIN

Esta consulta retorna todos os registros da tabela esquerda (tabela A) e as correspondências que existirem com a tabela direita (tabela B). O código ficará da seguinte forma:

RIGHT JOIN

Esta consulta retornará todos os registros da tabela direita (tabela B) e as correspondências que existirem com a tabela esquerda (tabela A). O código ficará da seguinte forma:

OUTER JOIN

Este JOIN também é conhecido como FULL OUTER JOIN ou FULL JOIN. Esta consulta retornará todos os registros das duas tabelas e juntando também os registros correspondentes entres as duas tabelas. O código ficará da seguinte forma:

LEFT Excluding JOIN

Esta consulta retornará apenas os registros da tabela esquerda que não têm correspondência com a tabela direita. O código ficará da seguinte forma:

RIGHT “excluindo” JOIN

Esta consulta retornará todos os registros da tabela esquerda que não têm correspondência com a tabela direita. O código ficará da seguinte forma:

OUTER “excluindo” JOIN

Esta consulta retornará todos os registros das duas tabelas que não têm correspondência. O código ficará da seguinte forma:

Para quem tiver interesse na figura completa com os JOINs demonstrados, segue abaixo o link:

O autor do artigo original se chama C.L. Moffatt, quem tiver interesse no artigo original e os exemplos que este autor utilizou, segue o link abaixo:

http://www.codeproject.com/KB/database/Visual_SQL_Joins.aspx

This post is a continuation of the post on SQL joins. Hopefully you have a better understanding of the types of joins available to you. Now it’s time to see how we can use them to detect orphaned rows.

An orphaned row is a child row that has no parent row. Going back to our example of the invoice metaphor, an invoice is usally broken down to two or more tables. The header table contains rows that carry information about the invoice as a whole. It would contain columns that usually have the following type of data:

• CUSTOMER_ID
• INVOICE_ID
• INVOICE_NUMBER
• INVOICE_DATE
• INVOICE_REF

The invoice detail table usually contains information specific to an invoice line item. An example of some columns that can be found in this type of table are:

• INVOICE_LINE_ID
• INVOICE_ID
• LINE_NUMBER
• ITEM_NUMBER
• QTY
• UNIT_PRICE
• LINE_TOTAL

In the example above it is often said that the invoice header is the parent of the invoice detail and that the invoice detail is the child of the invoice header. Normally, this relationship is easy to enforce. Suppose however that the relationship hasn’t been enforced and you suspect that you have some orphaned detail records. How could you go about finding them?

This is where the OUTER JOINS that we covered in our previous post comes in handy. Again, using our previous test data that was defined in the previous post let’s write a query that finds any invoice detail line that does not have a invoice header associated to it. Run the query below:

Code

select
   det.*
from dbo.invHdr hdr (nolock)
right join dbo.invDet det (nolock)
on det.invnum = hdr.invnum
where
   hdr.invnum is null

Notice that it returns one row. If you were to visually inspect the data in the detail table you would find that this is the row that is missing an invoice header. Notice that we are doing a RIGHT JOIN here. Remember that a RIGHT JOIN returns all matching rows and all non-matching rows from the right. Keep in mind that the header table is the “left” table and that the detail table is the “right” table. How is it then that the query above returned only one row?

The answer lies in the WHERE clause that was specified. It filters out the data after the join is made and tells SQL to return only the rows from the detail table where there is no matching header row. This is an example of an orphaned record.

To detect header rows that have no detail (these aren’t considered orphaned rows because the term applies to child tables) we can run the query below:

Code

select
   hdr.*
from dbo.invHdr hdr (nolock)
left join dbo.invDet det (nolock)
on det.invnum = hdr.invnum
where
   det.invnum is null

Now let’s assume we want to find any rows in the invoice header or invoice detail table that is missing it’s associated parent or child row. We could write the query like this:

Code

select
   hdr.*, det.*
from dbo.invHdr hdr (nolock)
full outer join dbo.invDet det (nolock)
on det.invnum = hdr.invnum
where
   hdr.invnum is null
   or det.invnum is null

Here we have instructed SQL (via the WHERE clause) to include any row where the invoice number is not in the header table or the detail table. This in affect returns all rows where either a child is missing it’s parent or where the parent has no detail.

I hope you find this post and it’s companion post useful. Please feel free to make any comments or suggestions regarding this post.

Minh

What is a JOIN?  Simply put, it is an operation that combines records from two or more tables.  There are three types of joins in SQL.  They are as follows:

• INNER JOIN (most common type)
• OUTER JOIN
• CROSS JOIN

Let’s look at an INNER JOIN.  What does it do?  An inner join is an operation that combines two or more tables into one resultset based on matches found in one or more columns in each of the participating tables.  For example, let’s say you have an INVOICE_HEADER table and an INVOICE_DETAIL table.  Assume that the two tables are defined as follows:

Create Tables

create table dbo.invHdr
(
  invnum varchar(5) not null
  ,customer varchar(30) not null
  ,invdate datetime not null default (getdate())
)
go

create table dbo.invDet
(
  invnum varchar(5) not null
  ,trandate datetime not null default (getdate())
  ,itemnum varchar(10) not null
  ,itemdesc varchar(100) not null
  ,qty numeric(10, 2) not null default (0)
  ,unitprice numeric(10, 2) not null
)
go

Now let’s create some test data for our examples:

Populate Tables

----- Insert header records. -----
insert into dbo.invHdr
(
  invnum, customer
)
values
(
  '00001', 'CUSTA'
)

insert into dbo.invHdr
(
  invnum, customer
)
values
(
  '00002', 'CUSTA'
)

insert into dbo.invHdr
(
  invnum, customer
)
values
(
  '00003', 'CUSTB'
)

----- Insert detail records. -----
insert into dbo.invDet
(
  invnum
  ,trandate
  ,itemnum
  ,itemdesc
  ,qty
  ,unitprice
)
values
(
  '00001'
  ,'4/1/2008'
  ,'I-BEV1'
  ,'COKE, 6PACK'
  ,3
  ,5
)

insert into dbo.invDet
(
  invnum
  ,trandate
  ,itemnum
  ,itemdesc
  ,qty
  ,unitprice
)
values
(
  '00005'
  ,'4/10/2008'
  ,'I-BEV2'
  ,'COKE, 12PACK'
  ,1
  ,9
)

INNER JOIN

Now that we’ve got some test data, let’s see how to do each type of join and look at the data it returns. First up is the INNER JOIN. Run this select statement:

----- Inner join. -----
select
  a.*, b.*
from dbo.invHdr a (nolock)
join dbo.invDet b (nolock)
on b.invnum = a.invnum

INNER JOIN example

Notice that the SELECT statement has returned a single row where a matching invoice number (invnum) was found in both the header and detail table.

LEFT JOIN

Now let’s look at what a LEFT JOIN would return. Run this statement:

-- Left join.
select
  a.*, b.*
from dbo.invHdr a (nolock)
left join dbo.invDet b (nolock)
on b.invnum = a.invnum

LEFT JOIN example

Notice how the LEFT JOIN statement returns all matching rows from both tables and all rows from the “left” table regardless of whether there are rows in the “right” table. The image below depicts this graphically.

LEFT JOIN depiction

The area in the middle are the matching rows. The area on the left (blue) are all the rows from the “left” table where no matches were found in the “right” table. However, since the type of JOIN is a LEFT JOIN, the rows from the left table are returned as well. The area on the right (white) are the rows from the “right” table. Only the colored areas are returned as part of the result.

You might be asking “How do I know which is the left table versus the right table?” The answer is simple. When you do any type of join, each table that is added to the join is considered to be the right table in relation to the table before it. For example, suppose we were to JOIN tables X, Y, and Z like so:

X –> Y –> Z

Here, X is considered to be the “left” table in relation to Y. Likewise, the table Y is considered to be the “left” table in relation to Z. It follows therefore that X is considered to be the “left” table in relation to Z. Some DBAs are under the misconception that the equal sign determines which table is “left” or “right”. Not so. For example, the two SELECT statements below would return identical results:

SELECT statement 1

select a*, b.*
from dbo.invHdr a (nolock)
left join dbo.invDet b (nolock)
on a.invnum = b.invnum

SELECT statement 2

select a.*, b.*
from dbo.invHdr a (nolock)
left join dbo.invDet b (nolock)
on b.invnum = a.invnum

As you can see, the same results are returned. The ON statement simply states the relationship between the two tables. That is, that they are related via the invnum column.

RIGHT JOIN

This type of join is simply the inverse of the LEFT JOIN. A right join returns all rows where matches were found in both tables as well as all rows from the right table. Here is a graphic that shows this concept:

RIGHT JOIN depiction

If we were to re-write the SELECT statement used in the LEFT JOIN example to be a RIGHT JOIN, it would look like this:

select a.*, b.*
from dbo.invHdr a (nolock)
right join dbo.invDet b (nolock)
on b.invnum = a.invnum

Notice that the only change that was made was to change the word LEFT to RIGHT. If you were to run this statement, you would see a result set similar to the LEFT JOIN example graphic. The only difference would be that for some rows, the columns for the LEFT table would be NULL.

Keep in mind that is because we are asking for all rows that match between the two tables and ALL rows from the right table regardless if a match was found on the left table.

FULL OUTER JOIN

Now let’s look at a full outer join. This type of join returns all matching rows and all non-matching rows. Below is a depiction of this concept. As you can see, all the colored sections indicate the rows that would be returned.

FULL OUTER JOIN depiction

Run the following statement below to see the results:

Code

select
   a.*, b.*
from dbo.invHdr a (nolock)
full outer join dbo.invDet b (nolock)
on b.invnum = a.invnum

As you can see, the rows that are returned include both the matching rows and the non-matching rows.

FULL OUTER JOIN example

CROSS JOIN

A CROSS JOIN is one in which all possible combinations of the two tables are returned. Run the code below to see the output:

select
   a.*, b.*
from dbo.invHdr a (nolock)
cross join dbo.invDet b (nolock)

As you can see from the graphic below, all the combinations of the records from both tables are returned.

CROSS JOIN example

In my next post I will show how you can use the LEFT JOIN, RIGHT JOIN or FULL OUTER JOIN to help you fined orphaned records in your tables. Orphaned records are a violation of database normalization rules and should be addressed if and when they are found.

Check back in a couple of days. Any feedback and/or comments are welcomed.
Minh

My post on detecting orphaned records is available here

Complete ref of SQL-Server Join, Inner Join, Left Outer Join, Right Outer Join, Full Outer Join, in SQL-Server 2005:

Merging data is heart of SQL and it shows the depth of relational algebra as well as the power and flexibility of SQL. SQL is excellent at selecting the data and SQL Developer can be master by understanding the relational algebra.

Join seems known technology but it is fun all time. Developer can make very creative query with joins by making data twist and shout. Pulling the data out of join could be the answer of very big code of programming language with iteration. It is much faster than any loop in your code. I promise you will have fun by learning this powerful technique.

SQL-Server 2005 is relational database so you always need to join more than one table in order to get complete information out of data tables. Since, tables are self explanatory itself, order of table doesn’t matter.

Here are the types of available joins in SQL-Server 2005:

Note: AdventureWorks database is going to be used throughout in this chapter.

Inner Join: It’s a very common and frequently needed join. Common intersection will be pulled out in this kind of join. It means, it will compare the result sets of first table with result sets of second table based on common fields or based on primary key and foreign key relationship. Below given is an example of Inner Join.

SELECT Sales.SalesPerson.SalesPersonID,

Sales.SalesPersonQuotaHistory.SalesQuota

FROM Sales.SalesPerson

INNER JOIN

Sales.SalesPersonQuotaHistory

ON

Sales.SalesPerson.SalesPersonID=Sales.SalesPersonQuotaHistory.SalesPersonID

You can get join two table with SalesPersonID in above case as both have common field.

(Part of Outer Join) Left Outer Join: Include all rows from the left side table no matter whether matching rows are exists in right side table or not. It means that Outer join is an extended version of Inner Join as it not only gives your common intersection but it do gives non matching data from left side or right side along with intersection.

SELECT HumanResources.Employee.EmployeeID,HumanResources.Employee.NationalIDNumber,

HumanResources.EmployeeAddress.AddressID

FROM HumanResources.Employee Left Outer Join HumanResources.EmployeeAddress

ON

HumanResources.Employee.EmployeeID=HumanResources.EmployeeAddress.EmployeeID

Employee table is joined with EmployeeAddress table based on EmployeeID. Left out join has been used so it will list all employees, no matter where it meets associated entry in EmployeeAddress.

(Part of Outer Join) Right Outer Join: Include all rows from the right side table no matter whether matching rows are exists in left side table or not. It means that Outer join is an extended version of Inner Join as it not only gives your common intersection but it do gives non matching data from left side or right side along with intersection.

SELECT HumanResources.Employee.EmployeeID,HumanResources.Employee.NationalIDNumber,

HumanResources.EmployeeAddress.AddressID

FROM HumanResources.Employee Right Outer Join HumanResources.EmployeeAddress

ON

HumanResources.Employee.EmployeeID=HumanResources.EmployeeAddress.EmployeeID

Employee table is joined with EmployeeAddress table based on EmployeeID. Right outer join has been used so it will list all employees’ Address, no matter where it meets associated entry in EmployeeAddress.

(Part of Outer Join) Full Outer Join: Includes all rows from both tables regardless of match exists. It means it a union distinct of Left Outer Join and Right Outer Join.

SELECT HumanResources.Employee.EmployeeID,HumanResources.Employee.NationalIDNumber,

HumanResources.EmployeeAddress.AddressID

FROM HumanResources.Employee Full Outer Join HumanResources.EmployeeAddress

ON

HumanResources.Employee.EmployeeID=HumanResources.EmployeeAddress.EmployeeID

Self Join: A self-join refers back to itself. You can use this type of unary relationship for recursive purpose. Like employee table to find boss.

–creating table for self join

create table emp

(

ID int Identity(1,1),

Name Varchar(15),

BossID int

)

GO

–Inserting some records in above table.

Insert Into emp

SELECT ‘DM’,0 UNION ALL

SELECT ‘MA’,1 UNION ALL

SELECT ‘UC’,2 UNION ALL

SELECT ‘LU’,2

GO

–equi join which will find boss name for every employee, DM is a main boss in this case.

SELECT e.ID,e.Name,ep.Name as ‘boss name’

FROM emp e JOIN emp ep

on

e.bossid=ep.id

GO

There are few more types of join like theta join, equi join, natural join etc. which I will explain in coming article.

Reference: Ritesh Shah

SQL RIGHT JOIN Keyword

The RIGHT JOIN keyword Return all rows from the right table (table_name2), even if there are no matches in the left table (table_name1).

SQL RIGHT JOIN Syntax

SELECT column_name(s)
FROM table_name1
RIGHT JOIN table_name2
ON table_name1.column_name=table_name2.column_name

PS: In some databases RIGHT JOIN is called RIGHT OUTER JOIN.

SQL RIGHT JOIN Example

The “Persons” table:

The “Orders” table:

Now we want to list all the orders with containing persons – if any, from the tables above.

We use the following SELECT statement:

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
RIGHT JOIN Orders
ON Persons.P_Id=Orders.P_Id
ORDER BY Persons.LastName

The result-set will look like this:

The RIGHT JOIN keyword returns all the rows from the right table (Orders), even if there are no matches in the left table (Persons).

SQL LEFT JOIN Keyword

The LEFT JOIN keyword returns all rows from the left table (table_name1), even if there are no matches in the right table (table_name2).

SQL LEFT JOIN Syntax

SELECT column_name(s)
FROM table_name1
LEFT JOIN table_name2
ON table_name1.column_name=table_name2.column_name

PS: In some databases LEFT JOIN is called LEFT OUTER JOIN.

SQL LEFT JOIN Example

The “Persons” table:

The “Orders” table:

Now we want to list all the persons and their orders – if any, from the tables above.

We use the following SELECT statement:

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
LEFT JOIN Orders
ON Persons.P_Id=Orders.P_Id
ORDER BY Persons.LastName

The result-set will look like this:

The LEFT JOIN keyword returns all the rows from the left table (Persons), even if there are no matches in the right table (Orders).

SQL INNER JOIN Keyword

The INNER JOIN keyword return rows when there is at least one match in both tables.
SQL INNER JOIN Syntax

SELECT column_name(s)
FROM table_name1
INNER JOIN table_name2
ON table_name1.column_name=table_name2.column_name

PS: INNER JOIN is the same as JOIN.
SQL INNER JOIN Example

The “Persons” table:
P_Id    LastName    FirstName      Address             City
1            Hansen          Ola                  Timoteivn 10    Sandnes
2            Svendson      Tove             Borgvn 23           Sandnes
3            Pettersen      Kari               Storgt 20             Stavanger

Note that the “P_Id” column is the primary key in the “Persons” table. This means that no two rows can have the same P_Id. The P_Id distinguishes two persons even if they have the same name.

The “Orders” table:
O_Id     OrderNo      P_Id
1             77895          3
2             44678          3
3             22456           1
4             24562           1
5             34764          15
Now we want to list all the persons with any orders.

We use the following SELECT statement:

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
INNER JOIN Orders
ON Persons.P_Id=Orders.P_Id
ORDER BY Persons.LastName

The result-set will look like this:
LastName     FirstName     OrderNo
Hansen           Ola                    22456
Hansen           Ola                    24562
Pettersen       Kari                  77895
Pettersen       Kari                  44678

The INNER JOIN keyword return rows when there is at least one match in both tables. If there are rows in “Persons” that do not have matches in “Orders”, those rows will NOT be listed.

SQL joins are used to query data from two or more tables, based on a relationship between certain columns in these tables.
SQL JOIN

The JOIN keyword is used in an SQL statement to query data from two or more tables, based on a relationship between certain columns in these tables.

Tables in a database are often related to each other with keys.

A primary key is a column (or a combination of columns) with a unique value for each row. Each primary key value must be unique within the table. The purpose is to bind data together, across tables, without repeating all of the data in every table.

Look at the “Persons” table:
P_Id    LastName    FirstName      Address             City
1            Hansen          Ola                  Timoteivn 10    Sandnes
2            Svendson      Tove             Borgvn 23           Sandnes
3            Pettersen      Kari               Storgt 20             Stavanger

Note that the “P_Id” column is the primary key in the “Persons” table. This means that no two rows can have the same P_Id. The P_Id distinguishes two persons even if they have the same name.

Next, we have the “Orders” table:
O_Id     OrderNo      P_Id
1             77895          3
2             44678          3
3             22456           1
4             24562           1
5             34764          15

Note that the “O_Id” column is the primary key in the “Orders” table and that the “P_Id” column refers to the persons in the “Persons” table without using their names.

Notice that the relationship between the two tables above is the “P_Id” column.
Different SQL JOINs

Before we continue with examples, we will list the types of JOIN you can use, and the differences between them.

* JOIN: Return rows when there is at least one match in both tables
* LEFT JOIN: Return all rows from the left table, even if there are no matches in the right table
* RIGHT JOIN: Return all rows from the right table, even if there are no matches in the left table
* FULL JOIN: Return rows when there is a match in one of the tables

INNER JOIN
Inner join only returns a result that will contain matching records from both tables.

OUTER JOIN
An outer join is the inverse of the inner join. It only returns those records not in both tables.

LEFT JOIN
A left join returns all the records in the “left” table whether they have a match in the right table or not.

If, however, they do have a match in the right table – give me the “matching” data from the right table as well. If not – fill in the holes with null.

RIGHT JOIN
A right join returns all the records in the “right” table whether they have a match in the left table or not.

If, however, they do have a match in the left table – give me the “matching” data from the left table as well. If not – fill in the holes with null.

FULL JOIN
Result will contain all records from both tables, and fill in NULLs for missing matches on either side

LEFT OUTER JOIN
A left outer join combines the ideas behind a left join and an outer join. Basically – if you use a left outer join you will get the records in the left table that DO NOT have a match in the right table.

RIGHT OUTER JOIN
A right outer join combines the ideas behind a right join and an outer join. Basically – if you use a right outer join you will get the records in the right table that DO NOT have a match in the left table.

I got this info from the net

Visual Explanation of Joins
‘Getting’ JOINS
Using MySQL JOINS
SQL JOIN
W3C Schools.com

Nas minhas pesquisas sobre o JOIN achei uma explicação muito boa e didática sobre a cláusula. Quem escreveu isso num fórum foi o Herleson Pontes (http://www.officeceara.com.br):

————————————————————

Vamos as explicações: suponha que você tenha duas tabelas: Clientes e Vendas, relacionadas entre si. Na tabela de Clientes, você tem o cadastro de todos os clientes da loja. Na tabela de Vendas, você tem as vendas que foram realizadas pelos clientes da loja. suponha ainda que não é obrigado o cliente ser cadastrado para efetuar uma venda.

Neste cenário, podemos ter três situações:

1) Existem clientes que ainda não fizeram nenhuma compra na loja;
2) Existem vendas que foram efetuadas por clientes não cadastrados no sistema;
3) Existem vendas que foram realizadas por clientes cadastrados.

Entendido o contexto acima, fica fácil de entender os JOINS. Basicamente, a sintaxe seria a abaixo:

SELECT campos FROM Clientes c TIPO_DE_JOIN JOIN Venda v ON c.cod_cliente = v.cod_cliente;

Veja agora como aplicar cada tipo de Join:

INNER JOIN: O Inner Join é utilizado nas situações em que você quer selecionar os registro das duas tabelas, desde que as mesmas possuam informações cruzadas (relacionadas). No nosso exemplo, é o JOIN que resolve a situação 3: a consulta vai retornar os clientes cadastrados que efetuaram compras.

SELECT campos FROM Clientes c INNER JOIN Venda v ON c.cod_cliente = v.cod_cliente;

OUTER JOIN: O Outer join possui o funcionamento um pouco diferente do anterior. Ao usar o Outer join, além de podermos retornar os registros das duas tabelas seguindo alguma relação, ainda podemos retornar registros que não entram nesta relação, que é a situação mais usada.

Você tem duas opções para se utilizar no Outer Join:

- LEFT OUTER JOIN (ou simplesmente LEFT JOIN): Aplica o conceito de Outer Join na tabela que se encontrar à esquerda da relação (ou seja, o resultado vem da tabela à esquerda). No nosso exemplo, é o JOIN que resolve a situação 1: a consulta retorna apenas os clientes que ainda não efetuaram nenhuma compra na loja.

SELECT campos FROM Clientes c LEFT OUTER JOIN Venda v ON c.cod_cliente = v.cod_cliente WHERE c.cod_cliente IS NULL;

- RIGHT OUTER JOIN (ou simplesmente RIGHT JOIN): Aplica o conceito de Outer Join na tabela que se encontrar à direita da relação (ou seja, o resultado vem da tabela à direita). No nosso exemplo, é o JOIN que resolve a situação 2: a consulta retorna apenas asvendas que foram realizadas por clientes não cadastrados na loja.

SELECT campos FROM Clientes c RIGHT OUTER JOIN Venda v ON c.cod_cliente = v.cod_cliente WHERE v.cod_cliente IS NULL;

————————————————————

Do you work with huge datasets?  Are you interested in the opportunities that abound when the world’s free open data are integrated and the Semantic Web becomes a reality?  Come discuss data mashups, visualizations, and tools to organize, discover and explore rich information streams.

Join us at Mangia pizza on Guadalupe (3016 Guadalupe #100: free wifi, beer & great pizza) Thursday July 10th at 6:30pm and meet your fellow Austin data nerds.

(Also at Upcoming)