程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 數據庫知識 >> 其他數據庫知識 >> PostgreSQL >> PostgreSQL教程(十):性能提升技巧

PostgreSQL教程(十):性能提升技巧

編輯:PostgreSQL

一、使用EXPLAIN:

    PostgreSQL為每個查詢都生成一個查詢規劃,因為選擇正確的查詢路徑對性能的影響是極為關鍵的。PostgreSQL本身已經包含了一個規劃器用於尋找最優規劃,我們可以通過使用EXPLAIN命令來查看規劃器為每個查詢生成的查詢規劃。
    PostgreSQL中生成的查詢規劃是由1到n個規劃節點構成的規劃樹,其中最底層的節點為表掃描節點,用於從數據表中返回檢索出的數據行。然而,不同的掃描節點類型代表著不同的表訪問模式,如:順序掃描、索引掃描,以及位圖索引掃描等。如果查詢仍然需要連接、聚集、排序,或者是對原始行的其它操作,那麼就會在掃描節點"之上"有其它額外的節點。並且這些操作通常都有多種方法,因此在這些位置也有可能出現不同的節點類型。EXPLAIN將為規劃樹中的每個節點都輸出一行信息,顯示基本的節點類型和規劃器為執行這個規劃節點計算出的預計開銷值。第一行(最上層的節點)是對該規劃的總執行開銷的預計,這個數值就是規劃器試圖最小化的數值。
    這裡有一個簡單的例子,如下:
 復制代碼 代碼如下:
    EXPLAIN SELECT * FROM tenk1;
                             QUERY PLAN
    -------------------------------------------------------------
     Seq Scan on tenk1  (cost=0.00..458.00 rows=10000 width=244)
    
    EXPLAIN引用的數據是:
    1). 預計的啟動開銷(在輸出掃描開始之前消耗的時間,比如在一個排序節點裡做排續的時間)。
    2). 預計的總開銷。
    3). 預計的該規劃節點輸出的行數。
    4). 預計的該規劃節點的行平均寬度(單位:字節)。
    這裡開銷(cost)的計算單位是磁盤頁面的存取數量,如1.0將表示一次順序的磁盤頁面讀取。其中上層節點的開銷將包括其所有子節點的開銷。這裡的輸出行數(rows)並不是規劃節點處理/掃描的行數,通常會更少一些。一般而言,頂層的行預計數量會更接近於查詢實際返回的行數。
    現在我們執行下面基於系統表的查詢:
 復制代碼 代碼如下:
    SELECT relpages, reltuples FROM pg_class WHERE relname = 'tenk1';
 
    從查詢結果中可以看出tenk1表占有358個磁盤頁面和10000條記錄,然而為了計算cost的值,我們仍然需要知道另外一個系統參數值。
 復制代碼 代碼如下:
    postgres=# show cpu_tuple_cost;
     cpu_tuple_cost
    ----------------
     0.01
    (1 row)
     cost = 358(磁盤頁面數) + 10000(行數) * 0.01(cpu_tuple_cost系統參數值)
    
     下面我們再來看一個帶有WHERE條件的查詢規劃。
  復制代碼 代碼如下:
    EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 7000;
   
                             QUERY PLAN
    ------------------------------------------------------------
     Seq Scan on tenk1  (cost=0.00..483.00 rows=7033 width=244)
       Filter: (unique1 < 7000)
   
    EXPLAIN的輸出顯示,WHERE子句被當作一個"filter"應用,這表示該規劃節點將掃描表中的每一行數據,之後再判定它們是否符合過濾的條件,最後僅輸出通過過濾條件的行數。這裡由於WHERE子句的存在,預計的輸出行數減少了。即便如此,掃描仍將訪問所有10000行數據,因此開銷並沒有真正降低,實際上它還增加了一些因數據過濾而產生的額外CPU開銷。
    上面的數據只是一個預計數字,即使是在每次執行ANALYZE命令之後也會隨之改變,因為ANALYZE生成的統計數據是通過從該表中隨機抽取的樣本計算的。
    如果我們將上面查詢的條件設置的更為嚴格一些的話,將會得到不同的查詢規劃,如:
 復制代碼 代碼如下:
    EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100;

                                      QUERY PLAN
    ------------------------------------------------------------------------------
     Bitmap Heap Scan on tenk1  (cost=2.37..232.35 rows=106 width=244)
       Recheck Cond: (unique1 < 100)
       ->  Bitmap Index Scan on tenk1_unique1  (cost=0.00..2.37 rows=106 width=0)
             Index Cond: (unique1 < 100)
   
    這裡,規劃器決定使用兩步規劃,最內層的規劃節點訪問一個索引,找出匹配索引條件的行的位置,然後上層規劃節點再從表裡讀取這些行。單獨地讀取數據行比順序地讀取它們的開銷要高很多,但是因為並非訪問該表的所有磁盤頁面,因此該方法的開銷仍然比一次順序掃描的開銷要少。這裡使用兩層規劃的原因是因為上層規劃節點把通過索引檢索出來的行的物理位置先進行排序,這樣可以最小化單獨讀取磁盤頁面的開銷。節點名稱裡面提到的"位圖(bitmap)"是進行排序的機制。

    現在我們還可以將WHERE的條件設置的更加嚴格,如:
 復制代碼 代碼如下:
    EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 3;

                                      QUERY PLAN
    ------------------------------------------------------------------------------
     Index Scan using tenk1_unique1 on tenk1  (cost=0.00..10.00 rows=2 width=244)
       Index Cond: (unique1 < 3)
   
    在該SQL中,表的數據行是以索引的順序來讀取的,這樣就會令讀取它們的開銷變得更大,然而事實上這裡將要獲取的行數卻少得可憐,因此沒有必要在基於行的物理位置進行排序了。
    現在我們需要向WHERE子句增加另外一個條件,如:
 復制代碼 代碼如下:
    EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 3 AND stringu1 = 'xxx';
   
                                      QUERY PLAN
    ------------------------------------------------------------------------------
     Index Scan using tenk1_unique1 on tenk1  (cost=0.00..10.01 rows=1 width=244)
       Index Cond: (unique1 < 3)
       Filter: (stringu1 = 'xxx'::name)
   
    新增的過濾條件stringu1 = 'xxx'只是減少了預計輸出的行數,但是並沒有減少實際開銷,因為我們仍然需要訪問相同數量的數據行。而該條件並沒有作為一個索引條件,而是被當成對索引結果的過濾條件來看待。
    如果WHERE條件裡有多個字段存在索引,那麼規劃器可能會使用索引的AND或OR的組合,如:
 復制代碼 代碼如下:
    EXPLAIN SELECT * FROM tenk1 WHERE unique1 < 100 AND unique2 > 9000;
    
                                         QUERY PLAN
    -------------------------------------------------------------------------------------
     Bitmap Heap Scan on tenk1  (cost=11.27..49.11 rows=11 width=244)
       Recheck Cond: ((unique1 < 100) AND (unique2 > 9000))
       ->  BitmapAnd  (cost=11.27..11.27 rows=11 width=0)
             ->  Bitmap Index Scan on tenk1_unique1  (cost=0.00..2.37 rows=106 width=0)
                   Index Cond: (unique1 < 100)
             ->  Bitmap Index Scan on tenk1_unique2  (cost=0.00..8.65 rows=1042 width=0)
                   Index Cond: (unique2 > 9000)
   
    這樣的結果將會導致訪問兩個索引,與只使用一個索引,而把另外一個條件只當作過濾器相比,這個方法未必是更優。
    現在讓我們來看一下基於索引字段進行表連接的查詢規劃,如:
 復制代碼 代碼如下:
    EXPLAIN SELECT * FROM tenk1 t1, tenk2 t2 WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2;
     
                                          QUERY PLAN
    --------------------------------------------------------------------------------------
     Nested Loop  (cost=2.37..553.11 rows=106 width=488)
       ->  Bitmap Heap Scan on tenk1 t1  (cost=2.37..232.35 rows=106 width=244)
             Recheck Cond: (unique1 < 100)
             ->  Bitmap Index Scan on tenk1_unique1  (cost=0.00..2.37 rows=106 width=0)
                   Index Cond: (unique1 < 100)
       ->  Index Scan using tenk2_unique2 on tenk2 t2  (cost=0.00..3.01 rows=1 width=244)
             Index Cond: ("outer".unique2 = t2.unique2)
   
    從查詢規劃中可以看出(Nested Loop)該查詢語句使用了嵌套循環。外層的掃描是一個位圖索引,因此其開銷與行計數和之前查詢的開銷是相同的,這是因為條件unique1 < 100發揮了作用。 這個時候t1.unique2 = t2.unique2條件子句還沒有產生什麼作用,因此它不會影響外層掃描的行計數。然而對於內層掃描而言,當前外層掃描的數據行將被插入到內層索引掃描中,並生成類似的條件t2.unique2 = constant。所以,內層掃描將得到和EXPLAIN SELECT * FROM tenk2 WHERE unique2 = 42一樣的計劃和開銷。最後,以外層掃描的開銷為基礎設置循環節點的開銷,再加上每個外層行的一個迭代(這裡是 106 * 3.01),以及連接處理需要的一點點CPU時間。   
    如果不想使用嵌套循環的方式來規劃上面的查詢,那麼我們可以通過執行以下系統設置,以關閉嵌套循環,如:
 復制代碼 代碼如下:
    SET enable_nestloop = off;
    EXPLAIN SELECT * FROM tenk1 t1, tenk2 t2 WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2;
     
                                            QUERY PLAN
    ------------------------------------------------------------------------------------------
     Hash Join  (cost=232.61..741.67 rows=106 width=488)
       Hash Cond: ("outer".unique2 = "inner".unique2)
       ->  Seq Scan on tenk2 t2  (cost=0.00..458.00 rows=10000 width=244)
       ->  Hash  (cost=232.35..232.35 rows=106 width=244)
             ->  Bitmap Heap Scan on tenk1 t1  (cost=2.37..232.35 rows=106 width=244)
                   Recheck Cond: (unique1 < 100)
                   ->  Bitmap Index Scan on tenk1_unique1  (cost=0.00..2.37 rows=106 width=0)
                         Index Cond: (unique1 < 100)
   
    這個規劃仍然試圖用同樣的索引掃描從tenk1裡面取出符合要求的100行,並把它們存儲在內存中的散列(哈希)表裡,然後對tenk2做一次全表順序掃描,並為每一條tenk2中的記錄查詢散列(哈希)表,尋找可能匹配t1.unique2 = t2.unique2的行。讀取tenk1和建立散列表是此散列聯接的全部啟動開銷,因為我們在開始讀取tenk2之前不可能獲得任何輸出行。

    此外,我們還可以用EXPLAIN ANALYZE命令檢查規劃器預估值的准確性。這個命令將先執行該查詢,然後顯示每個規劃節點內實際運行時間,以及單純EXPLAIN命令顯示的預計開銷,如:
 復制代碼 代碼如下:
    EXPLAIN ANALYZE SELECT * FROM tenk1 t1, tenk2 t2 WHERE t1.unique1 < 100 AND t1.unique2 = t2.unique2;     
                                                                QUERY PLAN
    ----------------------------------------------------------------------------------------------------------------------------------
     Nested Loop  (cost=2.37..553.11 rows=106 width=488) (actual time=1.392..12.700 rows=100 loops=1)
       ->  Bitmap Heap Scan on tenk1 t1  (cost=2.37..232.35 rows=106 width=244) (actual time=0.878..2.367 rows=100 loops=1)
             Recheck Cond: (unique1 < 100)
             ->  Bitmap Index Scan on tenk1_unique1  (cost=0.00..2.37 rows=106 width=0) (actual time=0.546..0.546 rows=100 loops=1)
                   Index Cond: (unique1 < 100)
       ->  Index Scan using tenk2_unique2 on tenk2 t2  (cost=0.00..3.01 rows=1 width=244) (actual time=0.067..0.078 rows=1 loops=100)
             Index Cond: ("outer".unique2 = t2.unique2)
     Total runtime: 14.452 ms
   
    注意"actual time"數值是以真實時間的毫秒來計算的,而"cost"預估值是以磁盤頁面讀取數量來計算的,所以它們很可能是不一致的。然而我們需要關注的只是兩組數據的比值是否一致。

    在一些查詢規劃裡,一個子規劃節點很可能會運行多次,如之前的嵌套循環規劃,內層的索引掃描會為每個外層行執行一次。在這種情況下,"loops"將報告該節點執行的總次數,而顯示的實際時間和行數目則是每次執行的平均值。這麼做的原因是令這些真實數值與開銷預計顯示的數值更具可比性。如果想獲得該節點所花費的時間總數,計算方式是用該值乘以"loops"值。
    EXPLAIN ANALYZE顯示的"Total runtime"包括執行器啟動和關閉的時間,以及結果行處理的時間,但是它並不包括分析、重寫或者規劃的時間。
    如果EXPLAIN命令僅能用於測試環境,而不能用於真實環境,那它就什麼用都沒有。比如,在一個數據較少的表上執行EXPLAIN,它不能適用於數量很多的大表,因為規劃器的開銷計算不是線性的,因此它很可能對大些或者小些的表選擇不同的規劃。一個極端的例子是一個只占據一個磁盤頁面的表,在這樣的表上,不管它有沒有索引可以使用,你幾乎都總是得到順序掃描規劃。規劃器知道不管在任何情況下它都要進行一個磁盤頁面的讀取,所以再增加幾個磁盤頁面讀取用以查找索引是毫無意義的。

二、批量數據插入:

    有以下幾種方法用於優化數據的批量插入。

    1. 關閉自動提交:

    在批量插入數據時,如果每條數據都被自動提交,當中途出現系統故障時,不僅不能保障本次批量插入的數據一致性,而且由於有多次提交操作的發生,整個插入效率也會受到很大的打擊。解決方法是,關閉系統的自動提交,並且在插入開始之前,顯示的執行begin transaction命令,在全部插入操作完成之後再執行commit命令提交所有的插入操作。
    
    2. 使用COPY:

    使用COPY在一條命令裡裝載所有記錄,而不是一系列的INSERT命令。COPY命令是為裝載數量巨大的數據行優化過的,它不像INSERT命令那樣靈活,但是在裝載大量數據時,系統開銷也要少很多。因為COPY是單條命令,因此在填充表的時就沒有必要關閉自動提交了。 
    
    3. 刪除索引:

    如果你正在裝載一個新創建的表,最快的方法是創建表,用COPY批量裝載,然後創建表需要的任何索引。因為在已存在數據的表上創建索引比維護逐行增加要快。當然在缺少索引期間,其它有關該表的查詢操作的性能將會受到一定的影響,唯一性約束也有可能遭到破壞。
    
    4. 刪除外鍵約束:
    和索引一樣,"批量地"檢查外鍵約束比一行行檢查更加高效。因此,我們可以先刪除外鍵約束,裝載數據,然後在重建約束。
    
    5. 增大maintenance_work_mem:
    在裝載大量數據時,臨時增大maintenance_work_mem系統變量的值可以改進性能。這個系統參數可以提高CREATE INDEX命令和ALTER TABLE ADD FOREIGN KEY命令的執行效率,但是它不會對COPY操作本身產生多大的影響。
    
    6. 增大checkpoint_segments:
    臨時增大checkpoint_segments系統變量的值也可以提高大量數據裝載的效率。這是因為在向PostgreSQL裝載大量數據時,將會導致檢查點操作(由系統變量checkpoint_timeout聲明)比平時更加頻繁的發生。在每次檢查點發生時,所有的髒數據都必須flush到磁盤上。通過提高checkpoint_segments變量的值,可以有效的減少檢查點的數目。
    
    7. 事後運行ANALYZE:
    在增加或者更新了大量數據之後,應該立即運行ANALYZE命令,這樣可以保證規劃器得到基於該表的最新數據統計。換句話說,如果沒有統計數據或者統計數據太過陳舊,那麼規劃器很可能會選擇一個較差的查詢規劃,從而導致查詢效率過於低下。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved