在2个谓词上使用OR进行连接的性能比较与2个单独的联接中的每个谓词的性能比较

Question

What's the performance impact on using a join using 2 predicates with an OR on the ON clause like so:

 SELECT GS.GuitarType,GD,GuitarColor
 FROM Prod.Guitars GS
 LEFT JOIN Prod.Guitar_Detail GD ON (GS.GuitarID = GD.GuitarID OR GS.GuitarID  = GD.GuitarCatNum)

VS. something like this:

 SELECT GS.GuitarType,GD,GuitarColor
 FROM Prod.Guitars GS
 LEFT JOIN Prod.Guitar_Detail GD ON GS.GuitarID = GD.GuitarID 
 LEFT JOIN Prod.Guitar_Detail GD2 ON GS.GuitarID  = GD.GuitarCatNum

Couple caveats: We have to use LEFT JOIN can't use INNER. I've ran both of the queries and the latter performs better.

Also another question, the 2nd won't return more rows right? Because they're both being joined on the same table, they should both preserve the GS table only right?

In the first query does it have to match twice? Or why does it perform different than the second?

Answer 1

Let me answer in a reversed order.

Also another question, the 2nd won't return more rows right? Because they're both being joined on the same table, they should both preserve the GS table only right?

The queries are different (the difference being in how nulls are treated), and the different execution times should be expected. Everything boils down to how GD.GuitarID and GD.GuitarCatNum are used.

a) If GD.GuitarID is set and GD.GuitarCatNum null, the queries will return the same data.
b) If GD.GuitarID is set and GD.GuitarCatNum contains the same value as GD.GuitarID, the second query will return duplicate rows.
c) If GD.GuitarID is null and GD.GuitarCatNum set, the queries will return the same number of rows, but GD.GuitarColor will be returned as null.

Now, assuming case a), the execution plans look like this:

Case 1)

SELECT 
  GS.GuitarType,
  GD.GuitarColor 
FROM 
  Guitars GS 
  LEFT JOIN Guitar_Detail GD 
  ON (GS.GuitarID = GD.GuitarID OR 
      GS.GuitarID = GD.GuitarCatNum)

Access Plan:
-----------
    Total Cost:         18.3602
    Query Degree:       1

              Rows 
             RETURN
             (   1)
              Cost 
               I/O 
               |
                3 
             >NLJOIN
             (   2)
             18.3602 
                2 
         /-----+------\
        2               1.5 
     TBSCAN           TBSCAN
     (   3)           (   4)
     8.99536          9.07676 
        1                1 
       |                |
        2                2 
 TABLE: DB2INST1    TABLE: DB2INST1  
     GUITARS       GUITAR_DETAIL
       Q2               Q1

Case 2)

SELECT 
  GS.GuitarType,
  GD.GuitarColor 
FROM 
  Guitars GS 
  LEFT JOIN Guitar_Detail GD 
  ON GS.GuitarID = GD.GuitarID 
  LEFT JOIN Guitar_Detail GD2 
  ON GS.GuitarID = GD.GuitarCatNum

    Total Cost:         27.2798
    Query Degree:       1

                               Rows 
                              RETURN
                              (   1)
                               Cost 
                                I/O 
                                |
                                 2 
                              >NLJOIN
                              (   2)
                              27.2798 
                                 3 
                 /--------------+---------------\
                2                                  1 
             HSJOIN<                            NLJOIN
             (   3)                             (   6)
             18.0326                            9.01796 
                2                                  1 
         /-----+------\                     /-----+------\
        2                2                0.5               2 
     TBSCAN           TBSCAN            TBSCAN           TBSCAN
     (   4)           (   5)            (   7)           (   8)
     8.99536          8.99536           0.0226           8.99536 
        1                1                 0                1 
       |                |                 |                |
        2                2                 1                2 
 TABLE: DB2INST1    TABLE: DB2INST1    TABFNC: SYSIBM    TABLE: DB2INST1  
  GUITAR_DETAIL       GUITARS           GENROW        GUITAR_DETAIL
       Q2               Q1                Q4               Q6

Hope this helps.

Answer 2

OR usually performs badly especially in joins. It is best to design your database so that you don't need these types of joins.

However, we are all stuck with the design at times, in that case, it is often more performant to use a UNION ALL (if the two join fields are mutually exlcusive). A UNION would be slower but better if the fields are not mutually exclusive and you don't want duplicates.