SQL column=ALL(query): Equivalent meaning I know that the expression:

WHERE column &lt;&gt; ALL(subquery)


could have been written as:

WHERE column NOT IN(subquery)


What would be the equivalent for

WHERE column = ALL(subquery)


I don’t think there would be any differences between dialects of SQL which support the ALL operator.
If not mistaken you can use a not exists predicate and negate the operator for ALL in the subquery. Something like:

SELECT ...
FROM T
WHERE T.x = ALL ( select y from U ) 


corresponds to

SELECT ...
FROM T
WHERE NOT EXISTS ( select 1 from U
                   WHERE NOT T.x = U.y )


I.e.

WHERE NOT EXISTS ( select 1 from U
                   WHERE T.x &lt;&gt; U.y )


In other words, for the predicate = ALL to hold there must NOT EXISTS a tuple that does satisfy NOT =  

Note that this might not hold if nulls are taken into consideration. Example:

with t (n) as ( values (1),(1),(2) ) 
select * from t as t1 
where not exists (select n from t as t2 where t1.n &lt;&gt; t2.n )


and:

with t (n) as ( values (1),(1),(2) ) 
select * from t where n = all (select n from t)


Both return 0 rows. However:

with t (n) as ( values (1),(1),(2),(null) ) 
select * from t where n = all (select n from t)


return 0 rows whereas:

with t (n) as ( values (1),(1),(2),(null) ) 
select * from t as t1 where not exists (select n from t as t2 where t1.n &lt;&gt; t2.n )


return 1 row. 

Three-valid logic makes things a whole lot more complicated, and one needs to be even more careful than usual when doing query rewrites.

FWIW, there is an really interesting project that applies Homotopy Type Theory (HoTT) to pseudo SQL:

http://cosette.cs.washington.edu/

The idea is to be able to prove whether two queries are equvalent, and if not provide an example of situations where they are not. Any vendor that adopts this to there dialect of SQL will have an killer app for sure.