Thank you for taking the time to reformat the SQL statement, demonstrating your formatting approach for ANSI style SQL statements. When there are three or more tables accessed, your formatting approach helps considerably to improve readability.

Also, thank you for helping to add value to this blog article.

I would also place each new table’s column first in its ON condition for reasons done to death here: http://jonathanlewis.wordpress.com/2006/11/02/clarity-clarity-clarity, but basically to be consistent with ‘where empno = 7839′ and ‘where deptno is not null’ type of constructions (i.e. rather than ‘where 7839 = empno’ and, umm, ‘where null is not deptno’). Apparently some people’s brains are wired the other way around to mine, but I always have to edit the code to read that way before I can make any sense of it. That gives me a FROM clause along the lines of:

FROM   customer_order co

       JOIN cust_order_line col
       ON   col.cust_order_id = co.id

       JOIN part p
       ON   p.id = col.part_id

       LEFT JOIN shipper_line sl
       ON   sl.cust_order_id = col.cust_order_id
       AND  sl.cust_order_line_no = col.line_no

       LEFT JOIN shipper s
       ON   s.packlist_id = sl.packlist_id

WHERE  COALESCE(sl.shipped_qty,1) > 0
AND    p.description LIKE 'PUMP%';

Thanks for stopping by and for reformatting my SQL statement. I am still trying to find the best format for ANSI style SQL statements – I like the ability of vertically scanning a SQL statement to be able to pick out the list of tables that are involved in the SQL statement, as I am able to do with the Oracle specific join syntax. That approach seems to make a mess when applied to ANSI syntax (maybe I just need to indent the ON clause another 4 spaces). Your reformatted version of the SQL statement is easier on the eyes than my version – but I still miss the ability to quickly see the list of tables and the restrictions applied to each table.

I am a little surprised how many ANSI related bugs are fixed in 11.2.0.2 or 12.1, but then I suppose that each transformation that a typical SQL statement using Oracle syntax is subjected to must also be considered for those SQL statements using ANSI syntax (if the transformation typically happens before the ANSI to Oracle syntax conversion) – if 11.2.0.1 introduces a new transformation to better optimize a SQL statement, it could potentially break the ANSI equivalent SQL statement.

Thank you for the comment and the suggested reformatting. I adopted the rather rigid uppercase formatting/indenting roughly 10 or 11 years ago, and that formatting doesn’t seem to flow well for the ANSI style join syntax. With the following as your starting point, how would you adjust the formatting to make the ANSI style join easier to read?

select
  co.id,
  s.shipped_date,
  col.line_no,
  p.id,
  p.description,
  sl.shipped_qty
from
  customer_order co
  join cust_order_line col on co.id=col.cust_order_id
 
  join part p on col.part_id=p.id
 
  left join shipper_line sl on col.cust_order_id=sl.cust_order_id
    and col.line_no=sl.cust_order_line_no
 
  left join shipper s on sl.packlist_id=s.packlist_id
where
  coalesce(sl.shipped_qty,1) > 0
  and p.description like 'PUMP%';

If you would like to include a formatted code section in your reply, please use a code tag in square brackets before the section and a /code tag in square brackets after the section.

Funny. I would say the opposite in terms of readability. I think the ANSI way is mush more readable than the Oracle way. I switched almost as soon as it became available in 9i. Probably the biggest thing that “turned” me was dealing with developers from a multi-engine background. It just got easier to use ANSI than having to keep reminding people what all the (+) signs meant.

I know formatting is a personal thing, but I think the formatting you use makes it very difficult to read. I think of each join as a single line in the from clause If the line gets too wide then I wrap it, but if possible it stays on the same line. So that statement you listed that looked a total nightmare would look like this.

SELECT
  CO.ID,
  S.SHIPPED_DATE,
  COL.LINE_NO,
  P.ID,
  P.DESCRIPTION,
  SL.SHIPPED_QTY
FROM
  CUSTOMER_ORDER CO
  INNER JOIN CUST_ORDER_LINE COL ON CO.ID=COL.CUST_ORDER_ID
  INNER JOIN PART P ON COL.PART_ID=P.ID
  LEFT OUTER JOIN SHIPPER_LINE SL ON COL.CUST_ORDER_ID=SL.CUST_ORDER_ID
    AND COL.LINE_NO=SL.CUST_ORDER_LINE_NO
  LEFT OUTER JOIN SHIPPER S ON SL.PACKLIST_ID=S.PACKLIST_ID
WHERE
  COALESCE(SL.SHIPPED_QTY,1) > 0
  AND P.DESCRIPTION LIKE 'PUMP%'; 

Pretty simple. Of course, if you don’t like the ANSI syntax you probably still think it looks like a nightmare.

I agree the bug thing is a bit of a problem. In one of the 10g versions you had to write all outer joins as left outer joins because right outer joins just didn’t work.

Cheers

Tim…