首先，先簡單解釋一下笛卡爾積。

現在，我們有兩個集合A和B。

A = {0,1}     B = {2,3,4}

集合 A×B 和 B×A的結果集就可以分別表示為以下這種形式：

A×B = {（0，2），（1，2），（0，3），（1，3），（0，4），（1，4）}；

B×A = {（2，0），（2，1），（3，0），（3，1），（4，0），（4，1）}；

以上A×B和B×A的結果就可以叫做兩個集合相乘的‘笛卡爾積’。

從以上的資料分析我們可以得出以下兩點結論：

1，兩個集合相乘，不滿足交換率，既 A×B ≠ B×A;

2，A集合和B集合相乘，包含了集合A中元素和集合B中元素相結合的所有的可能性。既兩個集合相乘得到的新集合的元素個數是 A集合的元素個數 × B集合的元素個數;

資料庫表連線資料行匹配時所遵循的演算法就是以上提到的笛卡爾積，表與表之間的連線可以看成是在做乘法運算。

比如現在資料庫中有兩張表，student表和 student_subject表，如下所示：

我們執行以下的sql語句，只是純粹的進行表連線。

SELECT * from student JOIN student_subject;
SELECT * from student_subject JOIN student;

看一下執行結果：

　　表1.0　　　　　　　　　　　　　　　　　　　　　　　　　 　　表1.1

從執行結果上來看，結果符合我們以上提出的兩點結論（紅線標註部分）；

以第一條sql語句為例我們來看一下他的執行流程，

1，from語句把student表 和 student_subject表從資料庫檔案載入到記憶體中。

2，join語句相當於對兩張表做了乘法運算，把student表中的每一行記錄按照順序和student_subject表中記錄依次匹配。

3，匹配完成後，我們得到了一張有 （student中記錄數 × student_subject表中記錄數）條的臨時表。 在記憶體中形成的臨時表如表1.0所示。我們又把記憶體中表1.0所示的表稱為‘笛卡爾積表’。

　　針對以上的理論，我們提出一個問題，難道表連線的時候都要先形成一張笛卡爾積表嗎，如果兩張表的資料量都比較大的話，那樣就會佔用很大的記憶體空間這顯然是不合理的。所以，我們在進行表連線查詢的時候一般都會使用JOIN xxx ON xxx的語法，ON語句的執行是在JOIN語句之前的，也就是說兩張表資料行之間進行匹配的時候，會先判斷資料行是否符合ON語句後面的條件，再決定是否JOIN。

　　因此，有一個顯而易見的SQL優化的方案是，當兩張表的資料量比較大，又需要連線查詢時，應該使用 FROM table1 JOIN table2 ON xxx的語法，避免使用 FROM table1,table2 WHERE xxx 的語法，因為後者會在記憶體中先生成一張資料量比較大的笛卡爾積表，增加了記憶體的開銷。

根據上一篇部落格(http://www.cnblogs.com/cdf-opensource-007/p/6502556.html)，及本篇部落格的分析，我們可以總結出一條查詢sql語句的執行流程。

From

ON

JOIN

WHERE

GROUP BY

SELECT

HAVING

ORDER BY

LIMIT

最後，針對兩張資料庫表連線的底層實現，我用java程式碼模擬了一下，感興趣的可以看一下，能夠幫助我們理解：

package com.opensource.util;

import java.util.Arrays;

public class DecareProduct {
    
    public static void main(String[] args) {
        
        //使用二維陣列，模擬student表
        String[][] student ={
                {"0","jsonp"},
                {"1","alice"}
        };
        
        //使用二維陣列，模擬student_subject表
        String[][] student_subject2 ={
                {"0","0","語文"},
                {"1","0","數學"}
        };

        //模擬 SELECT * from student JOIN student_subject;
        String[][] resultTowArray1 = getTwoDimensionArray(student,student_subject2);
        //模擬 SELECT * from student_subject JOIN student;
        String[][] resultTowArray2 = getTwoDimensionArray(student_subject2,student);
        
        int length1 = resultTowArray1.length;
        for (int i = 0; i <length1 ; i++) {
            System.out.println(Arrays.toString(resultTowArray1[i]));
        }
        System.err.println("-----------------------------------------------");
        int length2 = resultTowArray2.length;
        for (int i = 0; i <length2 ; i++) {
            System.out.println(Arrays.toString(resultTowArray2[i]));
        }
        
        
        
    }
    
    
    /**
     * 模擬兩張表連線的操作
     * @param towArray1
     * @param towArray2
     * @return
     */
    public static String[][] getTwoDimensionArray(String[][] towArray1,String[][] towArray2){
        
        //獲取二維陣列的高(既該二維陣列中有幾個一維陣列,用來指代資料庫表中的記錄數)
        int high1 = towArray1.length;
        int high2 = towArray2.length;
        
        //獲取二維陣列的寬度(既二位陣列中，一維陣列的長度,用來指代資料庫表中的列)
        int wide1 = towArray1[0].length;
        int wide2 = towArray2[0].length;
        
        //計算出兩個二維陣列進行笛卡爾乘積運算後獲得的結果集陣列的高度和寬度,既笛卡爾積表的行數和列數
        int resultHigh = high1 * high2;
        int resultWide = wide1 + wide2;
        
        //初始化結果集陣列,既笛卡爾積表
        String[][] resultArray = new String[resultHigh][resultWide];
        
        //迭代變數
        int index = 0;
        
        //先對第二二維陣列遍歷
        for (int i = 0; i < high2; i++) {
            
            //拿出towArray2這個二維陣列的元素
            String[] tempArray = towArray2[i];
            
            //迴圈巢狀，對第towArray1這個二維陣列遍歷
            for (int j = 0; j < high1; j++) {
                
                //初始化一個長度為'resultWide'的陣列,作為結果集陣列的元素,既笛卡爾積表中的一行
                String[] tempExtened = new String[resultWide];
                
                //拿出towArray1這個二維陣列的元素
                String[] tempArray1 = towArray1[j];
                
                //把tempArray1和tempArray兩個陣列的元素拷貝到結果集陣列的元素中去。(這裡用到了陣列擴容）
                System.arraycopy(tempArray1, 0, tempExtened, 0, tempArray1.length);
                System.arraycopy(tempArray, 0, tempExtened, tempArray1.length, tempArray.length);
                
                //把tempExtened放入結果集陣列中
                resultArray[index] = tempExtened;
                
                //迭代加一
                index++;
            }
        }
        
        return resultArray;
        
        
    }

}

執行結果：