When or why would you use a right outer join instead of left?

left join vs left outer join
what is the need for a right join when a left join does the same thing just in the reverse order
left outer join vs right outer join
difference between right join and right outer join
left join vs right join performance
right outer join
left outer join and right outer join in sql with example
mysql left outer join

Wikipedia states:

"In practice, explicit right outer joins are rarely used, since they can always be replaced with left outer joins and provide no additional functionality."

Can anyone provide a situation where they have preferred to use the RIGHT notation, and why? I can't think of a reason to ever use it. To me, it wouldn't ever make things more clear.

Edit: I'm an Oracle veteran making the New Year's Resolution to wean myself from the (+) syntax. I want to do it right

The only reason I can think of to use RIGHT OUTER JOIN is to try to make your SQL more self-documenting.

You might possibly want to use left joins for queries that have null rows in the dependent (many) side of one-to-many relationships and right joins on those queries that generate null rows in the independent side.

This can also occur in generated code or if a shop's coding requirements specify the order of declaration of tables in the FROM clause.

Right vs Left Outer Join Differences, I recently put together a lesson on the difference between right vs left outer join operators. It Duration: 13:27 Posted: Jul 31, 2018 You'll generally use the OUTER JOIN form that asks for all the rows from one table or result set and any matching rows from a second table or result set. To do this, you specify either a LEFT OUTER JOIN or a RIGHT OUTER JOIN.

I've never used right join before and never thought I could actually need it, and it seems a bit unnatural. But after I thought about it, it could be really useful in the situation, when you need to outer join one table with intersection of many tables, so you have tables like this:

And want to get result like this:

Or, in SQL (MS SQL Server):

declare @temp_a table (id int)
declare @temp_b table (id int)
declare @temp_c table (id int)
declare @temp_d table (id int)

insert into @temp_a
select 1 union all
select 2 union all
select 3 union all
select 4

insert into @temp_b
select 2 union all
select 3 union all
select 5

insert into @temp_c
select 1 union all
select 2 union all
select 4

insert into @temp_d
select id from @temp_a
union
select id from @temp_b
union
select id from @temp_c

select *
from @temp_a as a
    inner join @temp_b as b on b.id = a.id
    inner join @temp_c as c on c.id = a.id
    right outer join @temp_d as d on d.id = a.id

id          id          id          id
----------- ----------- ----------- -----------
NULL        NULL        NULL        1
2           2           2           2
NULL        NULL        NULL        3
NULL        NULL        NULL        4
NULL        NULL        NULL        5

So if you switch to the left join, results will not be the same.

select *
from @temp_d as d
    left outer join @temp_a as a on a.id = d.id
    left outer join @temp_b as b on b.id = d.id
    left outer join @temp_c as c on c.id = d.id

id          id          id          id
----------- ----------- ----------- -----------
1           1           NULL        1
2           2           2           2
3           3           3           NULL
4           4           NULL        4
5           NULL        5           NULL

The only way to do this without the right join is to use common table expression or subquery

select *
from @temp_d as d
    left outer join (
        select *
        from @temp_a as a
            inner join @temp_b as b on b.id = a.id
            inner join @temp_c as c on c.id = a.id
    ) as q on ...

Reason to prefer RIGHT JOIN over LEFT JOIN, I can't think of a time I've ever seen right join used in either code nor in examples. It's JOIN or LEFT OUTER JOIN . In rare cases you might see a  The only reason I can think of to use RIGHT OUTER JOIN is to try to make your SQL more self-documenting. You might possibly want to use left joins for queries that have null rows in the dependent (many) side of one-to-many relationships and right joins on those queries that generate null rows in the independent side.

B RIGHT JOIN A is the same as A LEFT JOIN B

B RIGHT JOIN A reads: B ON RIGHT, THEN JOINS A. means the A is in left side of data set. just the same as A LEFT JOIN B

There are no performance that can be gained if you'll rearrange LEFT JOINs to RIGHT.

The only reasons I can think of why one would use RIGHT JOIN is if you are type of person that like to think from inside side out (select * from detail right join header). It's like others like little-endian, others like big-endian, others like top down design, others like bottom up design.

The other one is if you already have a humongous query where you want to add another table, when it's a pain in the neck to rearrange the query, so just plug the table to existing query using RIGHT JOIN.

Difference between LEFT and RIGHT OUTER Joins in , This will be more clear by looking an example of RIGHT and LEFT outer join in SQL, LEFT vs RIGHT OUTER JOIN in SQL, MySQL database In order to understand difference between LEFT and RIGHT outer join, we will use once again use  An outer join is used to return results by combining rows from two or more tables. But unlike an inner join, the outer join will return every row from one specified table, even if the join condition fails. Take the phone directory example above.

The only time I would think of a right outer join is if I were fixing a full join, and it just so happened that I needed the result to contain all records from the table on the right. Even as lazy as I am, though, I would probably get so annoyed that I would rearrange it to use a left join.

This example from Wikipedia shows what I mean:

SELECT *  
FROM   employee 
   FULL OUTER JOIN department 
      ON employee.DepartmentID = department.DepartmentID

If you just replace the word FULL with RIGHT you have a new query, without having to swap the order of the ON clause.

A Visual Explanation of SQL Server RIGHT JOIN By Practical , In this tutorial, you will learn how to use the SQL Server RIGHT JOIN clause to query data from selecting data from the right table and matching with the rows from the left table. Note that RIGHT JOIN and RIGHT OUTER JOIN is the same. Use a full outer join when you want all the results from both sets. Use an inner join when you want only the results that appear in both sets. Use a left outer join when you want all the results from set a, but if set b has data relevant to some of set a's records, then you also want to use that data in the same query too.

SELECT * FROM table1 [BLANK] OUTER JOIN table2 ON table1.col = table2.col

Replace [BLANK] with:

LEFT - if you want all records from table1 even if they don't have a col that matches table2's (also included are table2 records with matches)

RIGHT - if you want all records from table2 even if they don't have a col that matches table1's (also included are table1 records with matches)

FULL - if you want all records from table1 and from table2

What is everyone talking about? They're the same? I don't think so.

Using a LEFT OUTER JOIN vs. RIGHT OUTER JOIN in SQL, You can use a search condition in the ON clause within a JOIN to specify a logical test that must be true in order to return any two linked rows. It  Because you wanted to use Right join instead of Left join. It may be more natural to write the SQL that way, or you just like the word RIGHT more than the word LEFT. Note: If you mix LEFT and RIGHT joins in the same query, you might get some odd results, but you mention none of that.

Why do we have Left Join and Right Join in SQL, if we can use Left , Why do we have Left Join and Right Join in SQL, if we can use Left Join to get What is the difference between a LEFT INNER JOIN vs a LEFT OUTER JOIN? As expected, by using a LEFT OUTER JOIN instead of the previous INNER JOIN, we’re getting the best of both worlds: We’re not skipping any books records (such as Hamlet) simply because the language_id value is null for that record, yet for all records where language_id exists, we get the nicely formatted language name obtained from our languages table.

Why do we need both Left and Right join when we can work with just , I think you'll find this discussion interesting and it may answer your question as well. In order to use the right join output in SQL, the query result finds all the rows from the second table and includes the matching rows from the left table. One thing you should notice that if there is no match in both the tables it returns a null value. How to Use RIGHT OUTER JOIN in SQL. If you want to perform the right outer join in SQL, you

SQL RIGHT JOIN vs RIGHT OUTER JOIN | Multiple Tables, SQL RIGHT JOIN vs RIGHT OUTER JOIN. SQL Is Null a join starting with the second (right-most) table and then any matching first (left-most) table records. This is a bit of a philosophical question about data.table join syntax. I am finding more and more uses for data.tables, but still learning The join format X[Y] for data.tables is very concise,

Comments
  • Or, put another way, you want to do it right and left (and full) :)
  • can be, sure, but correctly be? comes down to how limited a developers understanding of right outer joins is. They are NOT the same or they wouldn't be there. #sigh
  • +1, would accept answer if it summarized yours, Michael, and Ivan's.
  • we can able get same results using left outer join (by the way we get using right outer join).then why there is option for right join or vice versa?.
  • You don't need to nest a SELECT, you can nest a join instead: FROM @temp_d AS d LEFT OUTER JOIN (temp_a AS a INNER JOIN @temp_b AS b ON b.id = a.id INNER JOIN @temp_c AS c ON c.id = a.id) ON a.id = d.id. (The brackets are unnecessary, they are added just for readability.) It's true, though, that there are people who are undecided as to which syntax they abhor more, nested joins or right outer joins, so it's possible that right joins might work less badly for them. :)
  • Nice, i never used nested joins syntax as well :)
  • Actually, the last query with d as the main table looks a lot more readable - "One table is outer joined with a bunch of tables which are inner joined among themselves."
  • If a query starts with "select * from a" that table sounds like the main table. When some table much later in the sequence starts poking holes in the main table, it just seems weird.
  • Also, which columns can be referred in the following join "on" parts? Only the "main" table, or any of the preceding tables? I've not given it so much thought.
  • +1, would accept answer if it summarized yours, Jekke, and Ivan's.
  • no performance gained... not a great reason to learn to use the language as it was intended. If everything was done for performance reasons ruby and php and .net wouldn't be around anymore.