MYSQL Nested Join Optimization

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了MYSQL Nested Join Optimization，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5124字，纯文字阅读大概需要8分钟。

内容图文

等于：

SELECT * FROM t1 LEFT JOIN (t2 CROSS JOIN t3 CROSS JOIN t4)
                 ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c)

   在mysql中，cross join 语法上等效与 inner join(他们可以互相替换)，在标准sql中，他们并不等效，

   一般情况下，在只包含inner join操作的join表达式中，圆括号可以被忽略,但外连接时，省略圆括号会带来不一样的结果：

t1 LEFT JOIN (t2 LEFT JOIN t3 ON t2.b=t3.b OR t2.b IS NULL)
   ON t1.a=t2.a

  转变：

(t1 LEFT JOIN t2 ON t1.a=t2.a) LEFT JOIN t3
    ON t2.b=t3.b OR t2.b IS NULL

   然而，这两个表达式并不等效，假设：

 1： 表t1包含 行（1），（2）；
 2： 表t2包含行（1，101）； 
 3： 表t3包含行（101）；


 在这种情况下，第一个表达式返回的结果集包括（1，1，101，101） ，（2，null,null,null）,然而第二表达式返回（1，1，101，101），（2，null,null,101）;

mysql> select * from 
    ->    t1 left join 
    ->      (t2 left join t3 on t2.b = t3.b or t2.b is null )
    ->         on t1.a = t2.a;
+------+------+------+------+
| a    | a    | b    | b    |
+------+------+------+------+
|    1 |    1 |  101 |  101 |
|    2 | NULL | NULL | NULL |
+------+------+------+------+
2 rows in set (0.02 sec)

mysql> select * from
    ->    (t1 left join t2 on t1.a = t2.a)
    ->       left join t3
    ->           on t2.b = t3.b or t2.b is null;
+------+------+------+------+
| a    | a    | b    | b    |
+------+------+------+------+
|    1 |    1 |  101 |  101 |
|    2 | NULL | NULL |  101 |
+------+------+------+------+
2 rows in set (0.00 sec)

  <============================================================================>

t1 LEFT JOIN (t2, t3) ON t1.a=t2.a

 该表达式不能转变成：

t1 LEFT JOIN t2 ON t1.a=t2.a, t3.

Database changed
mysql> select * from t1 left join (t2,t3) on t1.a = t2.a;
+------+------+------+------+
| a    | a    | b    | b    |
+------+------+------+------+
|    1 |    1 |  101 |  101 |
|    2 | NULL | NULL | NULL |
+------+------+------+------+
2 rows in set (0.00 sec)

mysql> select * from t1 left join t2 on t1.a = t2.a, t3;
+------+------+------+------+
| a    | a    | b    | b    |
+------+------+------+------+
|    1 |    1 |  101 |  101 |
|    2 | NULL | NULL |  101 |
+------+------+------+------+
2 rows in set (0.00 sec)

不同的结果集

    因此，如果我们去掉有outer join操作的join表达式的圆括号，我们会改变原始表达式的结果集。

    更加准确的，我们不能去掉左外连接的右括号操作，和右外连接的左括号操作。换句话，我们不能去掉外连接操作中的内表表达式的括号，外表的其他操作括号可以被去掉；

(t1,t2) LEFT JOIN t3 ON P(t2.b,t3.b)

等效于：

t1, t2 LEFT JOIN t3 ON P(t2.b,t3.b)

SELECT * FROM t1 LEFT JOIN (t2 LEFT JOIN t3 ON t2.b=t3.b) ON t1.a=t2.a
  WHERE t1.a > 1

SELECT * FROM t1 LEFT JOIN (t2, t3) ON t1.a=t2.a
  WHERE (t2.b=t3.b OR t2.b IS NULL) AND t1.a > 1

这梁查询都包含内连接：

t2 LEFT JOIN t3 ON t2.b=t3.b
t2, t3

SELECT * FROM T1 INNER JOIN T2 ON P1(T1,T2)
                 INNER JOIN T3 ON P2(T2,T3)
  WHERE P(T1,T2,T3).

该表达式的执行顺序：

FOR each row t1 in T1 {
  FOR each row t2 in T2 such that P1(t1,t2) {
    FOR each row t3 in T3 such that P2(t2,t3) {
      IF P(t1,t2,t3) {
         t:=t1||t2||t3; OUTPUT t;
      }
    }
  }
}

SELECT * FROM T1 LEFT JOIN
              (T2 LEFT JOIN T3 ON P2(T2,T3))
              ON P1(T1,T2)
  WHERE P(T1,T2,T3).

顺序：

FOR each row t1 in T1 {
  BOOL f1:=FALSE;
  FOR each row t2 in T2 such that P1(t1,t2) {
    BOOL f2:=FALSE;
    FOR each row t3 in T3 such that P2(t2,t3) {
      IF P(t1,t2,t3) {
        t:=t1||t2||t3; OUTPUT t;
      }
      f2=TRUE;
      f1=TRUE;
    }
    IF (!f2) {
      IF P(t1,t2,NULL) {
        t:=t1||t2||NULL; OUTPUT t;
      }
      f1=TRUE;
    }
  }
  IF (!f1) {
    IF P(t1,NULL,NULL) {
      t:=t1||NULL||NULL; OUTPUT t;
    }
  }
}

    在一般情况下，对于在一外联接操作的任何嵌套循环的第一内表，一个标志被引入在循环之前处于关闭并在循环之后被检查。该标志被打开时，用于从外部表的当前行从代表内操作数表中找到一个匹配的。如果在循环周期结束的标志仍然关闭，没有发现匹配的外部表的当前行。在这种情况下，该行被用于内表的列补充NULL值。结果行被传递到最后的检查为输出或到下一个嵌套循环，但仅当行满足所有嵌入式外的连接条件。

     对于外连接的查询，优化器可以只选择为循环表外循环在内部表之前的顺序。因此，我们外部连接的查询，只有一个嵌套顺序是可能的。对于下面的查询，优化器将评估两个不同的嵌套：

SELECT * T1 LEFT JOIN (T2,T3) ON P1(T1,T2) AND P2(T1,T3)
  WHERE P(T1,T2,T3)

FOR each row t1 in T1 {
  BOOL f1:=FALSE;
  FOR each row t2 in T2 such that P1(t1,t2) {
    FOR each row t3 in T3 such that P2(t1,t3) {
      IF P(t1,t2,t3) {
        t:=t1||t2||t3; OUTPUT t;
      }
      f1:=TRUE
    }
  }
  IF (!f1) {
    IF P(t1,NULL,NULL) {
      t:=t1||NULL||NULL; OUTPUT t;
    }
  }
}

和：

FOR each row t1 in T1 {
  BOOL f1:=FALSE;
  FOR each row t3 in T3 such that P2(t1,t3) {
    FOR each row t2 in T2 such that P1(t1,t2) {
      IF P(t1,t2,t3) {
        t:=t1||t2||t3; OUTPUT t;
      }
      f1:=TRUE
    }
  }
  IF (!f1) {
    IF P(t1,NULL,NULL) {
      t:=t1||NULL||NULL; OUTPUT t;
    }
  }
}

如果P可以拆分：

P(T1,T2,T2) = C1(T1) AND C2(T2) AND C3(T3).

算法会变成

FOR each row t1 in T1 such that C1(t1) {
  FOR each row t2 in T2 such that P1(t1,t2) AND C2(t2)  {
    FOR each row t3 in T3 such that P2(t2,t3) AND C3(t3) {
      IF P(t1,t2,t3) {
         t:=t1||t2||t3; OUTPUT t;
      }
    }
  }
}

     每个合取C1（T1）的，C 2（T2），C 3（T3）被压出的最内环到最外循环在那里可以进行评估。如果C1（T 1）是一个非常严格的条件下，此条件下推可能大大从传递给内表T1减少行数。其结果是，在执行时间的查询可能提高极大。

MYSQL Nested Join Optimization

标签：

本文系统来源：http://www.cnblogs.com/onlysun/p/4525570.html

内容总结

以上是互联网集市为您收集整理的MYSQL Nested Join Optimization全部内容，希望文章能够帮你解决MYSQL Nested Join Optimization所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端