LEFT JOIN vs. LEFT OUTER JOIN in SQL Server

As per the documentation: FROM (Transact-SQL):

<join_type> ::= 
    [ { INNER | { { LEFT | RIGHT | FULL } [ OUTER ] } } [ <join_hint> ] ]
    JOIN

The keyword OUTER is marked as optional (enclosed in square brackets). In this specific case, whether you specify OUTER or not makes no difference. Note that while the other elements of the join clause is also marked as optional, leaving them out will make a difference.

For instance, the entire type-part of the JOIN clause is optional, in which case the default is INNER if you just specify JOIN. In other words, this is legal:

SELECT *
FROM A JOIN B ON A.X = B.Y

Here's a list of equivalent syntaxes:

A LEFT JOIN B            A LEFT OUTER JOIN B
A RIGHT JOIN B           A RIGHT OUTER JOIN B
A FULL JOIN B            A FULL OUTER JOIN B
A INNER JOIN B           A JOIN B

Also take a look at the answer I left on this other SO question: SQL left join vs multiple tables on FROM line?.

There is no difference between LEFT JOIN and LEFT OUTER JOIN, they are exactly same.

At the top level there are mainly 3 types of joins:

1. INNER JOIN fetches data if present in both the tables.

2. OUTER JOINs are of 3 types:

   1. LEFT OUTER JOIN - fetches data if present in the left table.
   2. RIGHT OUTER JOIN - fetches data if present in the right table.
   3. FULL OUTER JOIN - fetches data if present in either of the two tables.

3. CROSS JOIN, as the name suggests, does n times m pairings that join everything to everything. That is similar to where we simply list the tables for joining (in the FROM clause of the SELECT statement), using commas to separate them.

Points to be noted:

• If you just mention JOIN then by default it is an INNER JOIN.
• An OUTER join has to be LEFT | RIGHT | FULL; you can not simply say OUTER JOIN.
• You can drop the OUTER keyword and just say LEFT JOIN or RIGHT JOIN or FULL JOIN.

A Visual Explanation of SQL Joins

What is the difference between left join and left outer join?

Nothing. LEFT JOIN and LEFT OUTER JOIN are equivalent.

Left Join and Left Outer Join are one and the same. The former is the shorthand for the latter. The same can be said about the Right Join and Right Outer Join relationship. The demonstration will illustrate the equality. Working examples of each query have been provided via SQL Fiddle. This tool will allow for hands on manipulation of the query.

Given

Left Join and Left Outer Join

Results

Right Join and Right Outer Join

Results

I'm a PostgreSQL DBA. The difference between outer or not outer joins is a topic that has considerable discussion all around the internet.

If you look in PostgreSQL documentation:

The words INNER and OUTER are optional in all forms. INNER is the default; LEFT, RIGHT, and FULL imply an outer join. (http://www.postgresql.org/docs/8.4/static/queries-table-expressions.html)

In other words,

LEFT JOIN and LEFT OUTER JOIN ARE THE SAME

RIGHT JOIN and RIGHT OUTER JOIN ARE THE SAME

I find it easier to think of Joins in the following order:

• CROSS JOIN - a Cartesian product of both tables. ALL joins begin here
• INNER JOIN - a CROSS JOIN with a filter added.
• OUTER JOIN - an INNER JOIN with missing elements (from either LEFT or RIGHT table) added afterward.

Until I figured out this (relatively) simple model, JOINS were always a bit more of a black art. Now they make perfect sense.

In Sql Server joins syntax OUTER is optional.

https://msdn.microsoft.com/en-us/library/ms177634(v=sql.130).aspx

Equivalent join syntaxes with and without OUTER:

LEFT OUTER JOIN => LEFT JOIN
RIGHT OUTER JOIN => RIGHT JOIN
FULL OUTER JOIN => FULL JOIN

Other equivalent syntaxes:

INNER JOIN => JOIN
CROSS JOIN => ,

Illustration from Dotnet Mob article (strongly recommended) Joins in Sql Server:

Why are LEFT/RIGHT and LEFT OUTER/RIGHT OUTER the same? Let's explain why this vocabulary. Understand that LEFT and RIGHT joins are specific cases of the OUTER join, and therefore couldn't be anything else than OUTER LEFT/OUTER RIGHT. The OUTER join is also called FULL OUTER as opposed to LEFT and RIGHT joins that are PARTIAL results of the OUTER join. Indeed:

Table A | Table B     Table A | Table B      Table A | Table B      Table A | Table B
   1    |   5            1    |   1             1    |   1             1    |   1
   2    |   1            2    |   2             2    |   2             2    |   2
   3    |   6            3    |  null           3    |  null           -    |   -
   4    |   2            4    |  null           4    |  null           -    |   -
                        null  |   5             -    |   -            null  |   5
                        null  |   6             -    |   -            null  |   6

                      OUTER JOIN (FULL)     LEFT OUTER (partial)   RIGHT OUTER (partial)

It is now clear why those operations have aliases, as well as it is clear only 3 cases exist: INNER, OUTER, CROSS. With two sub-cases for the OUTER. The vocabulary, the way teachers explain this, as well as some answers above, often make it looks like there are lots of different types of join. But it's actually very simple.

There are only 3 joins:

• Cross Join = Cartesian Join (E.g: Table A, Table B)

• Inner Join = JOIN (E.g: Table A Join / Inner Join Table B)

• Outer Join

  There are three types:

  • Left Outer Join = Left Join
  • Right Outer Join = Right Join
  • Full Outer Join = Full Join

There are mainly three types of JOIN

1. Inner: fetches data, that are present in both tables
   • Only JOIN means INNER JOIN

2. Outer: are of three types

   • LEFT OUTER - - fetches data present only in left table & matching condition
   • RIGHT OUTER - - fetches data present only in right table & matching condition
   • FULL OUTER - - fetches data present any or both table
   • (LEFT or RIGHT or FULL) OUTER JOIN can be written w/o writing "OUTER"

3. Cross Join: joins everything to everything

Syntactic sugar, makes it more obvious to the casual reader that the join isn't an inner one.

JOINs:

1. INNER JOIN = JOIN

2. OUTER JOIN

   • LEFT OUTER JOIN = LEFT JOIN
   • RIGHT OUTER JOIN = RIGHT JOIN
   • FULL OUTER JOIN = FULL JOIN

3. CROSS JOIN

Self-JOIN: This is not exactly a separate type of join. This is joining a table to itself using one of the above joins. You will hear this term from many in the SQL Developer community.

There are two APPLY operators:

1. CROSS APPLY: Similar to INNER JOIN (But has the added advantage of being able to compute something in the right table for each row of the left table and returns only the matching rows.)
2. OUTER APPLY: Similar to LEFT OUTER JOIN (But has the added advantage of being able to compute something in the right table for each row of the left table and returns all the rows from the left table irrespective of a match on the right table.)

https://www.mssqltips.com/sqlservertip/1958/sql-server-cross-apply-and-outer-apply/

https://sqlhints.com/2016/10/23/outer-apply-in-sql-server/

Real life example, when to use OUTER / CROSS APPLY in SQL

The APPLY operators are very beneficial as they give better performance than doing the same computation in a subquery. They are also a replacement of many analytical functions in older versions of SQL Server. So after being comfortable with JOINS a SQL developer should learn the APPLY operators.

In SQL, the terms "LEFT JOIN" and "LEFT OUTER JOIN" are often used interchangeably. Both of these join types return all the rows from the left table (the table specified before the JOIN keyword) and the matching rows from the right table (the table specified after the JOIN keyword). However, there is a slight difference in the way they handle unmatched rows.

A LEFT JOIN or LEFT OUTER JOIN includes all the rows from the left table, regardless of whether there is a match in the right table. If there is no match, the result will contain NULL values in the columns of the right table.

Here's an example to illustrate the difference:

Let's assume we have two tables, Customers and Orders, with a common column CustomerID:

Customers Table:

CustomerID | CustomerName
-----------|--------------
1          | John
2          | Mary
3          | David

Orders Table:

OrderID | CustomerID | OrderDate
--------|------------|-----------
101     | 1          | 2023-01-01
102     | 2          | 2023-02-01

Using a LEFT JOIN or LEFT OUTER JOIN between these tables, the result would be:

SELECT *
FROM Customers
LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID;

Result:

CustomerID | CustomerName | OrderID | CustomerID | OrderDate
-----------|--------------|---------|------------|-----------
1          | John         | 101     | 1          | 2023-01-01
2          | Mary         | 102     | 2          | 2023-02-01
3          | David        | NULL    | NULL       | NULL

As you can see, the LEFT JOIN returns all rows from the left table (Customers), including the unmatched row (David) with NULL values in the columns from the right table (Orders).

With dbForge Query Builder for SQL Server, you can easily select the desired join type (including LEFT JOIN or LEFT OUTER JOIN) and visually construct your queries without needing to write the SQL code manually.