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

I always considered Left Outer Join in LINQ to be complex until today when I had to use it in my application. I googled and the first result gave a very nice explanation. The only difference between ordinary joins (inner joins) and left joins in LINQ is the use of “join into” and “DefaultIfEmpty()” expressions.

Consider this very simple query (Assuming a scenario that not all the TimesheetLines are associated with a Job)

Select TL.EntryDate, TL.Hours, J.JobName
From TimeSheetLines TL
Left Join Jobs J on TL.JobNo=J.JobNo

A LINQ query using inner join is

var lines =
    from tl in db.TimeSheetLines
    join j  in db.Jobs on tl.JobNo equals j.JobNo
    where tl.ResourceNo == resourceNo

    select new
    {
        EntryDate = tl.EntryDate,
        Hours = tl.Hours,
        Job = j.JobName
    };

And a LINQ query performing left join is

var lines =
    from tl in db.TimeSheetLines
    join j  in db.Jobs on tl.JobNo equals j.JobNo into tl_j
    where tl.ResourceNo == resourceNo

    from j in tl_j.DefaultIfEmpty()
    select new
    {
        EntryDate = tl.EntryDate,
        Hours = tl.Hours,
        Job = j.JobName
    };

Notice that the only difference is the use of “into” with the join statement followed by reselecting the result using “DefaultIfEmpty()” expression. And here’s the generated SQL from the above LINQ expression.

SELECT [t0].[EntryDate] as [EntryDate], [t0].[Hours] as [Hours], [t1].[JobName] AS [Job]
FROM [dbo].[TimeSheetLine] AS [t0]
LEFT OUTER JOIN [dbo].[Jobs] AS [t1] ON [t0].[JobNo] = [t1].[JobNo]
WHERE [t0].[ResourceNo] = @p0

Similar concept can be expanded for multiple left joins. Assuming that a TimeSheetLine will either have a JobNo or an IndirectCode, consider this SQL query:

Select TL.EntryDate, TL.Hours, J.JobName, I.IndirectName
From TimeSheetLines TL
Left Join Jobs J on TL.JobNo=J.JobNo
Left Join Indirects I on TL.IndirectCode=I.IndirectCode

The equivalent LINQ query is:

var lines =
    from tl in db.TimeSheetLines
    join j in db.Jobs      on tl.JobNo        equals j.JobNo            into tl_j
    join i in db.Indirects on tl.IndirectCode equals i.IndirectCode  into tl_i
    where tl.ResourceNo == resourceNo

    from j in tl_j.DefaultIfEmpty()
    from i in tl_i.DefaultIfEmpty()
    select new
    {
        EntryDate = tl.EntryDate,
        Hours = tl.Hours,
        Job = j.JobName,
        Indirect = i.IndirectName,
    };

And the generated SQL is:

SELECT [t0].[EntryDate] as [EntryDate], [t0].[Hours] as [Hours], [t1].[JobName] AS [Job], [t2].[IndirectName] As [Indirect]
LEFT OUTER JOIN [dbo].[Jobs] AS [t1] ON [t0].[JobNo] = [t1].[JobNo]
LEFT OUTER JOIN [dbo].[Indirects] AS [t2] ON [t0].[IndirectCode] = [t2].[IndirectCode]
WHERE [t0].[ResourceNo] = @p0

That’s all, left outer joins in LINQ are as easy as in T-SQL. Happy joining.

Muss das wirklich so grausam aussehen? So sahen jedenfalls die Beispiele aus, die ich gefunden habe:

Dim oDatenPlan = From oMon In listMonate _
Group Join oUppUp In dcUpp.tUppUmsatzPlans On oMon Equals oUppUp.Monat _
Into gVorlage = Group _
From oUppUp In gVorlage.DefaultIfEmpty() _
Where If(oUppUp Is Nothing, -1, oUppUp.FkFilialId) = oFiliale.FilialId _
And If(oUppUp Is Nothing, -1, oUppUp.FkAbtId) = abtId _
Select oMon

Learn Basic Concepts of Sql joins like
Inner Join
Outer Join
Cross Join
Self Join
etc..
in the most simpler manner by pinal dave in the form of venn diagram.
He has explained sql joins with proper examples.. very good article for newbies on sql server

http://dotnetslackers.com/articles/sql/SQL-SERVER-JOINs.aspx

So, the front end was working—the controller and the view seemed to function properly. I turned to the back end, the database.

Since the User Account  Management module is a sister of the Role Permissions Management module, which I finished earlier, I thought I wouldn’t have any more problems on the querying part. The two modules use the same database tables and I was advised by my supervisors to use left joins still, which I believed I properly utilized in the ‘Role’ module. However, a second look at the module I thought was “Ok na” revealed a fat database bug.

I thought I used the LEFT JOIN properly. What I needed was a query which would retrieve from two tables all the modules with their id and name and a value indicating whether or not the module is selected for a certain role. With left join, you retrieve all tuples that match on the join column and if there is an entry in the left table that has no match in the right table, the result will still contain the left table entry with the right table columns filled with nulls.

The problem that I did not notice before was that if, let’s say, for a module M, two roles R1 and R2 can access it where M is in Table1(the table of modules) and R1 and R2 are in Table2(the table listing accessible modules for roles), the result would contain two rows for module M: [M, R1] and [M, R2]. It would appear that there are two modules M where there is  only one.

In short, the query was in error all along. And the result, being erroneous, cannot be displayed.

I decided to fix the ‘Role’ module first before continuing the ‘User Account’ module (since they have similar queries).

Unfortunate for me, I was all alone at the office when I discovered the bug. No-coworkers nor supervisors yet. Thus, I tried to solve the database problem alone—in solitude—trying query modifications and visiting tutorials on the net. After many attempts to fix the query, the result was still wrong.

After a while, I realized I could solve the problem in the application layer instead. And after implementing a strategy, I finally got the correct output. I won’t outline the solution anymore because it would be too technical. Suffice it to say that I used loops and hash tables to produce the correct display.

Then, I applied the same application-layer strategy on the User Account Management module, and it worked

~Peter

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

Business Logic with JOIN – Multiple Join examples in SQL-Server 2005:

I wrote my previous article about different type of JOIN in SQL-Server 2005. Due to the space constraint in that article, complex example has not been given there, only few simple examples. I felt to explode this topic further by giving solution to some really needed business logic.

If you want to create report for blood testing laboratory, who used to check samples of employee of different companies for different purposes. Following should be the table structure, we will be creating three table. One will store information about Order received from different companies. Another one will be the detail of that order, means which company sent how much samples of how much employee?? And the last one is further more details about how much test should be performs on which sample???

Let us create three tables.

–CREATING FIRST ORDER TABLE

USE [AdventureWorks]

GO

/****** Object: Table [dbo].[Orders] Script Date: 03/08/2009 12:24:39 ******/

SET ANSI_NULLS ON

GO

SET QUOTED_IDENTIFIER ON

GO

SET ANSI_PADDING ON

GO

CREATE TABLE [dbo].[Orders](

[OrderID] [varchar](5) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

[OrderDate] [datetime] NOT NULL,

[CompanyName] [varchar](10) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,

PRIMARY KEY CLUSTERED

(

[OrderID] ASC

)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]

) ON [PRIMARY]

GO

SET ANSI_PADDING ON

Now, child table of above.

USE [AdventureWorks]

GO

/****** Object: Table [dbo].[OrderDetails] Script Date: 03/08/2009 12:37:27 ******/

SET ANSI_NULLS ON

GO

SET QUOTED_IDENTIFIER ON

GO

SET ANSI_PADDING ON

GO

CREATE TABLE [dbo].[OrderDetails](

[OrderID] [varchar](5) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,

[SampleNumber] [varchar](8) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

[SampleOfEmployee] [varchar](15) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

[SampleReceivedDate] [datetime] NULL,

PRIMARY KEY CLUSTERED

(

[SampleNumber] ASC

)

) ON [PRIMARY]

GO

SET ANSI_PADDING ON

GO

ALTER TABLE [dbo].[OrderDetails] WITH CHECK ADD CONSTRAINT [fk_orderid] FOREIGN KEY([OrderID])

REFERENCES [dbo].[Orders] ([OrderID])

GO

ALTER TABLE [dbo].[OrderDetails] CHECK CONSTRAINT [fk_orderid]

One more child table.

USE [AdventureWorks]

GO

/****** Object: Table [dbo].[sampledetails] Script Date: 03/08/2009 12:43:00 ******/

SET ANSI_NULLS ON

GO

SET QUOTED_IDENTIFIER ON

GO

SET ANSI_PADDING ON

GO

CREATE TABLE [dbo].[sampledetails](

[SampleNumber] [varchar](8) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

[TestType] [varchar](10) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,

PRIMARY KEY CLUSTERED

(

[SampleNumber] ASC,

[TestType] ASC

)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]

) ON [PRIMARY]

GO

SET ANSI_PADDING ON

Now, this is time to insert few records on above tables.

–Received three order from two company

INSERT INTO Orders

SELECT ‘L1000′,‘2009-03-01′,‘Test Inc.’ UNION ALL

SELECT ‘L1001′,‘2009-03-02′,‘Zeel Inc.’ UNION ALL

SELECT ‘L1002′,‘2009-03-04′,‘ABC Inc.’

–received two sample for first order, one sample for second order

–sample for third order yet to receive

INSERT INTO OrderDetails

SELECT ‘L1000′,‘L1000-01′,‘James’,‘2009-03-01′ UNION ALL

SELECT ‘L1000′,‘L1000-02′,‘John’,‘2009-04-01′ UNION ALL

SELECT ‘L1001′,‘L1001-01′,‘Smita’,‘2009-03-05′

–details of sample, which test suppose to be performed

–on which sample

INSERT INTO SampleDetails

SELECT ‘L1000-01′,‘Cancer’ UNION ALL

SELECT ‘L1000-01′,‘AIDS’ UNION ALL

SELECT ‘L1000-02′,‘BP’ UNION ALL

SELECT ‘L1001-01′,‘AIDS’ UNION ALL

SELECT ‘L1001-01′,‘Cancer’

Well, now we are ready to pull data out of three tables with different type of JOIN which we have seen in my previous article.

NOTE: many different logic can be used to perform following tasks, I am giving this just to explain the use of JOIN otherwise there are some more facility which can handle all of the below situation other than join.

If you want to get OrderID, OrderDate, Company (who gave the order??), SampleNumber, EmployeeName (for which employee company has sent the sample??), TestType (which test to be performed in above tables?)

You can use following query which has used one LEFT OUTER JOIN and one INNER JOIN.

SELECT O.OrderID,O.OrderDate,O.CompanyName,

OD.SampleofEmployee,OD.SampleNumber,SD.TestType

FROM

ORDERS AS O

LEFT OUTER JOIN

ORDERDETAILS AS OD

ON

O.OrderID=OD.OrderID

INNER JOIN

SampleDetails AS SD

ON

OD.SampleNumber=SD.SampleNumber

If there is a need to find how many samples came from which company. Use following query with aggregate function COUNT.

SELECT

O.CompanyName,Count(SampleNumber) as ‘TOTAL’

FROM

ORDERS AS O

LEFT OUTER JOIN

ORDERDETAILS AS OD

ON

O.OrderID=OD.OrderID

GROUP BY O.CompanyName

ORDER BY TOTAL DESC

Reference: Ritesh Shah

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 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

Este es un interesante script que devuelve la diferencia entre dos datatables. Su funcionamiento es similar a realizar un LEFT JOIN en Transact SQL. La diferencia es que en este método, utilizamos el objeto DataRelation de .NET. He tenido que utilizar este método ya que los origenes de los datatables, son de conexiones direferentes, por lo que la utilización de LEFT JOIN, no es posible.

///
/// Devuelve un datatable con las diferencias entre los datatables de entrada
///
///
1er datatable ///
2o datatable ///
public static DataTable Difference(DataTable First, DataTable Second)
{
//creamos una tabla vacia
DataTable table = new DataTable(“Diferencias”);

//creamos un dataSet para poder utilizar el objeto DataRelation
using (DataSet ds = new DataSet())
{
//añadimos una copia de las tablas
ds.Tables.AddRange(new DataTable[] { First.Copy(), Second.Copy() });
//creamos un dataColumn con las columnas del datatable 1.
DataColumn[] firstcolumns = new DataColumn[ds.Tables[0].Columns.Count];
for (int i = 0; i < firstcolumns.Length; i++)
{
firstcolumns[i] = ds.Tables[0].Columns[i];
}

DataColumn[] secondcolumns = new DataColumn[ds.Tables[1].Columns.Count];
for (int i = 0; i < secondcolumns.Length; i++)
{
secondcolumns[i] = ds.Tables[1].Columns[i];
}
//creamos la relación
DataRelation r = new DataRelation(string.Empty, firstcolumns, secondcolumns, false);
ds.Relations.Add(r);

//creamos las columnas en el datatable a devolver.
for (int i = 0; i < First.Columns.Count; i++)
{
table.Columns.Add(First.Columns[i].ColumnName, First.Columns[i].DataType);
}

//si la primera fila no esta en la segunda tabla, la añadimos a la tabla.
table.BeginLoadData();
foreach (DataRow parentrow in ds.Tables[0].Rows)
{
DataRow[] childrows = parentrow.GetChildRows(r);
if (childrows == null || childrows.Length == 0)
table.LoadDataRow(parentrow.ItemArray, true);
}
table.EndLoadData();
}

return table;
}

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;

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

Ada beberapa programmer yang dihadapkan dengan kasus membuat hirarki data dalam SQL database. Hirarki data mempunyai relasi parent-child, namun bersifat rekursif. Tidak natural dalam konsep relasional database. Hirarki data adalah data collection yang tiap itemnya mempunyai single parent atau tidak sama sekali dan mempunyai satu, dua atau lebih children. Hirarki data dapat kita jumpai dalam banyak aplikasi database, termasuk forum dan mailing list, diagram oraganisasi bisnis, produk, multi level marketing dan kode akun dalam accounting. dalam postingan ini, saya mencoba untuk membuat data hirarki dengan kasus membuat kode akun accounting. Contoh yang saya buat, kurang lebih sama dengan kasus-kasus yang lain seperti yang saya jelaskan diawal.

Sebelumnya, kita buat dulu tabel dengan nama tabelnya account (sekalian asaya buat fungsi CREATE dan INSERT jadi tinggal diikuti aja..)

CREATE TABLE `account` (
  `accountId` int(11) NOT NULL AUTO_INCREMENT,
  `parentId` int(11) DEFAULT NULL,
  `accountName` char(20) NOT NULL,
  PRIMARY KEY (`accountId`)
);

INSERT INTO `account` (`accountId`, `parentId`, `accountName`) VALUES
  (1, 0, 'Harta'),  (2, 1, 'Harta Lancar'),  (3, 2, 'Kas'),
  (4, 2, 'Bank'),  (5, 2, 'Piutang Teman'),  (6, 1, 'Harta Tetap'),
  (7, 6, 'Kendaraan'),  (8, 7, 'Vario Matic'),
  (9, 6, 'Product Electronic'),  (10, 6, 'Investasi'),
  (11, 0, 'Pendapatan'),  (12, 11, 'Gaji'),
  (13, 12, 'Gaji gue'),  (14, 11, 'Hasil Investasi');

 SELECT * FROM account;

 +-----------+----------+--------------------+
 | accountId | parentId | accountName        |
 +-----------+----------+--------------------+
 |         1 |        0 | Harta              |
 |         2 |        1 | Harta Lancar       |
 |         3 |        2 | Kas                |
 |         4 |        2 | Bank               |
 |         5 |        2 | Piutang Teman      |
 |         6 |        1 | Harta Tetap        |
 |         7 |        6 | Kendaraan          |
 |         8 |        7 | Vario Matic        |
 |         9 |        6 | Product Electronic |
 |        10 |        6 | Investasi          |
 |        11 |        0 | Pendapatan         |
 |        12 |       11 | Gaji               |
 |        13 |       12 | Gaji gue           |
 |        14 |       11 | Hasil Investasi    |
 +-----------+----------+--------------------+
 14 rows in set (0.00 sec)

Pada hasil dari SELECT diatas, bahwa tiap item pada tabel berisi parentId yang menunjuk ke parentnya. pada baris pertama dan 11 berisi 0. Ini berarti row tersebut tidak mempunyai parent atau bisa disebut sebagai parent itu sendiri. Model tabel diatas bisa diterjemahkan Vario Matic adalah child dari Kendaraan, Kendaraan adalah child dari Harta Tetap dan Harta Tetap adalah child dari Harta yang mana tidak mempunyai parent lagi alias parent itu sendiri. Walaupun tabel diatas sudah dapat diterjemahkan, tetapi masih dibutuhkan suatu query statement agar tampilan data collection lebih mudah untuk dilihat/dimengerti. Untuk menampilkan data tersebut dapat kita gunakan LEFT JOIN :

mysql> SELECT a1.accountName AS Parent, a2.accountName as Child1,
 ->   a3.accountName as Child2, a4.accountName as Child3
 ->   FROM account AS a1
 ->   LEFT JOIN account AS a2 ON a2.parentId = a1.accountId
 ->   LEFT JOIN account AS a3 ON a3.parentId = a2.accountId
 ->   LEFT JOIN account AS a4 ON a4.parentId = a3.accountId
 ->   WHERE a1.parentId =0;
+------------+-----------------+--------------------+-------------+
| Parent     | Child1          | Child2             | Child3      |
+------------+-----------------+--------------------+-------------+
| Harta      | Harta Lancar    | Kas                | NULL        |
| Harta      | Harta Lancar    | Bank               | NULL        |
| Harta      | Harta Lancar    | Piutang Teman      | NULL        |
| Harta      | Harta Tetap     | Kendaraan          | Vario Matic |
| Harta      | Harta Tetap     | Product Electronic | NULL        |
| Harta      | Harta Tetap     | Investasi          | NULL        |
| Pendapatan | Gaji            | Gaji gue           | NULL        |
| Pendapatan | Hasil Investasi | NULL               | NULL        |
+------------+-----------------+--------------------+-------------+
8 rows in set (0.00 sec)

Untuk menampilkan data account yang paling bawah atau account yang tidak mempunyai child, saya menggunakan LEFT JOIN:

mysql> SELECT aOne.accountName FROM
-> account AS aOne LEFT JOIN account as aTwo
 -> ON aOne.accountId = aTwo.parentId
 -> WHERE aTwo.accountId IS NULL;
+--------------------+
| accountName        |
+--------------------+
| Kas                |
| Bank               |
| Piutang Teman      |
| Vario Matic        |
| Product Electronic |
| Investasi          |
| Gaji gue           |
| Hasil Investasi    |
+--------------------+
8 rows in set (0.00 sec)

Namun, masih ada beberapa yang menurut saya kurang dari postingan ini. Bagaimana membuat query yang dinamis sehingga sewaktu menambahkan child baru tidak harus merubah struktur query yang sudah di buat. akan saya posting pada kesempatan yang akan datang.

Joining tables in queries across different MySQL databases is possible if you use fully qualified database and table names.

Both databases will need to be on the same server for this to work

SELECT  db1.table1.column1,
        db2.table1.column1
FROM    db1.table1 LEFT JOIN db2.table1
        ON
          (
            db1.table1.column2 = db2.table1.column2
          );

The example query will pull two columns (column1 from both databases) and display the results of the LEFT JOIN.