alt Hacker NewsI've used SQL for around a decade and also never came across it. I'm maintaining SQL code with hundreds if not thousands of basic primary key joins and this could make those queries way more concise. Now I want to know the reasons for not using USING!
There are reasons for not USING.
First, you need to be aware of the implicit disambiguration. When you join with USING, you are introducing a hidden column that represents both sides. This is typically what you want - but it can bite you.
Consider this PostgreSQL example:
``` CREATE TABLE foo (x INT); INSERT INTO foo VALUeS (1);
CREATE TABLE bar (x FLOAT); INSERT INTO bar VALUES (1);
SELECT pg_typeof(x) FROM foo JOIN bar USING (x); ```
The type of x is is double, - because x was implicitly upcast as we can see with EXPLAIN:
``` Merge Join (cost=338.29..931.54 rows=28815 width=4) Merge Cond: (bar.x = ((foo.x)::double precision)) -> Sort (cost=158.51..164.16 rows=2260 width=8) ```
Arguably, you should never be joining on keys of different types. It just bad design. But you don't always get that choice if someone else made the data model for you.
It also means that this actually works:
``` CREATE TABLE foo (x INT); INSERT INTO foo VALUeS (1);
CREATE TABLE bar (x INT); INSERT INTO bar VALUES (1);
CREATE TABLE baz (x INT); INSERT INTO baz VALUES (1);
SELECT * FROM foo JOIN bar USING (x) JOIN baz USING (x); ```
Which might not be what you expected :-)
If you are both the data modeller and the query writer - I have not been able to come up with a reason for not USING.