Tüm Ürünler
Search
Belge Merkezi

PolarDB:Esnek paralel sorgu çalıştırma planlarını görüntülemek için EXPLAIN ifadesini kullanın

Son Güncelleme:Oct 07, 2026

Bir sorgunun PolarDB for MySQL üzerinde paralel olarak çalışıp çalışmadığını doğrulamak ve çalıştırma planlarını incelemek amacıyla EXPLAIN ifadesini kullanın.

Çalışma mekanizması

Esnek paralel sorgu etkinleştirildiğinde, PolarDB bir sorguyu alt görevlere böler ve bunları bir veya daha fazla düğümdeki birden çok worker'a (işçiye) atar. Çalıştırma planı, standart EXPLAIN çıktı alanlarının yanı sıra paralele özgü işleçler içerecek şekilde bu durumu yansıtır.

Standart EXPLAIN çıktı alanları:

Alan Açıklama
Id Çalıştırma planındaki adım tanımlayıcısı
Select_type SELECT türü (örneğin, SIMPLE, PRIMARY, DEPENDENT SUBQUERY)
Table Bu adım tarafından erişilen tablo veya <gather2> gibi sanal bir düğüm
Type Birleştirme veya erişim türü (örneğin, index, range, ALL)
Key Kullanılan dizin
Rows İncelenmesi tahmin edilen satır sayısı
Filtered Filtre koşulunu geçen satırların tahmini yüzdesi
Extra Paralel işleçler dahil ek çalıştırma bilgileri

Paralele özgü işleçler:

İşleç Göründüğü yer İşlevi
Gather Üst düzey veya alt ağaç Tüm worker'lardan gelen kısmi sonuçları toplar ve tek bir sonuç kümesinde birleştirir
Parallel scan (N workers) Extra alanı N worker ile paralel tablo veya dizin taramasını gösterir
Parallel pushdown Extra alanı Bağımlı bir alt sorguyu paralel çalıştırma için worker'lara gönderir
Broadcast EXPLAIN FORMAT=TREE çıktısı Bir veri setinin kopyasını tüm worker'lara gönderir
Shared access EXPLAIN FORMAT=TREE çıktısı Paralel bir alt sorguyu bir kez çalıştırır ve sonucu worker'lar arasında paylaşır

Plan ağacındaki Gather düğümü, paralel ve seri çalıştırma arasındaki sınırı işaret eder. Bir Gather düğümünün altındaki her şey paralel olarak çalışır; üzerindeki her şey ise koordinatörde seri olarak çalışır.

Örnek tablo

Bu konudaki tüm örnekler pq_test tablosunu kullanır.

Şema:

SHOW CREATE TABLE pq_test\G
*************************** 1. row ***************************
       Table: pq_test
Create Table: CREATE TABLE `pq_test` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `help_topic_id` INT(10) UNSIGNED NOT NULL,
  `name` CHAR(64) NOT NULL,
  `help_category_id` SMALLINT(5) UNSIGNED NOT NULL,
  `description` TEXT NOT NULL,
  `example` TEXT NOT NULL,
  `url` TEXT NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=21495809 DEFAULT CHARSET=utf8
1 row in set (0.00 sec)

Tablo boyutu:

SHOW TABLE STATUS\G
*************************** 1. row ***************************
           Name: pq_test
         Engine: InnoDB
        Version: 10
     Row_format: Dynamic
           Rows: 20064988
 Avg_row_length: 1898
    Data_length: 38085328896
Max_data_length: 0
   Index_length: 0
      Data_free: 4194304
 Auto_increment: 21495809
    Create_time: 2019-07-30 01:35:27
     Update_time: NULL
      Check_time: NULL
       Collation: utf8_general_ci
        Checksum: NULL
 Create_options:
         Comment:
1 row in set (0.02 sec)

Test sorgusu:

SELECT COUNT(*) FROM pq_test;

Paralel olmayan bir sorgu planını görüntüleyin

Paralel sorguyu devre dışı bırakmak için max_parallel_degree değerini 0 olarak ayarlayın ve ardından EXPLAIN komutunu çalıştırın:

SET max_parallel_degree=0; EXPLAIN SELECT COUNT(*) FROM pq_test\G
*************************** 1. row ***************************
           Id: 1
  Select_type: SIMPLE
        Table: pq_test
   Partitions: NULL
         Type: index
Possible_keys: NULL
          Key: PRIMARY
      Key_len: 8
          Ref: NULL
         Rows: 20064988
     Filtered: 100.00
        Extra: Using index
1 row in set, 1 warning (0.03 sec)

Plan, standart bir dizin taraması göstermektedir. Bir Gather düğümü yoktur ve Extra alanında Parallel scan belirteci bulunmaz; bu da sorgunun seri olarak çalıştığını doğrular.

Paralel bir sorgu planını görüntüleyin

PolarDB for MySQL 8.0.1: EXPLAIN

EXPLAIN SELECT COUNT(*) FROM pq_test\G
*************************** 1. row ***************************
           Id: 1
  Select_type: SIMPLE
        Table: <gather2>
   Partitions: NULL
         Type: ALL
Possible_keys: NULL
          Key: NULL
      Key_len: NULL
          Ref: NULL
         Rows: 20064988
     Filtered: 100.00
        Extra: NULL
*************************** 2. row ***************************
           Id: 2
  Select_type: SIMPLE
        Table: pq_test
   Partitions: NULL
         Type: index
Possible_keys: NULL
          Key: PRIMARY
      Key_len: 8
          Ref: NULL
         Rows: 10032494
     Filtered: 100.00
        Extra: Parallel scan (2 workers); Using index
2 rows in set, 1 warning (0.00 sec)

Bir yerine iki satır görünür:

  • Satır (<gather2>), tüm worker'lardan gelen sonuçları toplayan ve birleştiren Gather işlemidir. Bu satır paralel sınırı işaret eder; bunun altındaki her şey paralel olarak çalışır.

  • Satır, Extra alanında Parallel scan (2 workers) ile pq_test üzerindeki gerçek taramayı gösterir; bu da 2 worker'ın dizin taramasını paralel olarak yürüttüğünü doğrular.

PolarDB for MySQL 8.0.2: EXPLAIN FORMAT=TREE

EXPLAIN FORMAT=TREE komutu, paralel çalıştırma yapısına ilişkin daha zengin ayrıntılarla ağaç şeklinde bir plan döndürür:

EXPLAIN FORMAT=TREE SELECT COUNT(*) FROM pq_test\G
*************************** 1. row ***************************
EXPLAIN: -> Count rows in gather  (cost=... rows=1)
    -> Gather (slice: 1; workers: 2, nodes: 2)
        -> Parallel index scan on pq_test using PRIMARY, with parallel partitions: 8  (cost=... rows=20064988)

Yukarıdan aşağıya okunduğunda:

  • Count rows in gather — Koordinatör, worker sonuçlarından nihai sayımı toplar.

  • Gather (slice: 1; workers: 2, nodes: 2) — 2 worker 2 düğümde çalışır. Bu, paralel sınırdır.

  • Parallel index scan on pq_test using PRIMARY, with parallel partitions: 8 — Dizin, paralel olarak taranan 8 bölüme ayrılır.

Alt sorgulu paralel bir sorgu planını görüntüleyin

PolarDB for MySQL 8.0.1: EXPLAIN

EXPLAIN SELECT
    o_orderpriority,
    COUNT(*) as order_count
FROM
    orders
WHERE
    o_orderdate >= '1994-04-01'
    AND o_orderdate < date_add('1994-04-01', interval '3' month)
    AND exists (
        SELECT
            *
        FROM
            lineitem
        WHERE
            l_orderkey = o_orderkey
            and l_commitdate < l_receiptdate
    )
GROUP BY
    o_orderpriority
ORDER BY
    o_orderpriority\G
*************************** 1. row ***************************
           id: 1
  select_type: PRIMARY
        table: <gather1.1>
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 1489068
     filtered: 100.00
        Extra: Using temporary; Using filesort
*************************** 2. row ***************************
           id: 1
  select_type: PRIMARY
        table: orders
   partitions: NULL
         type: range
possible_keys: i_o_orderdate
          key: i_o_orderdate
      key_len: 3
          ref: NULL
         rows: 568369
     filtered: 100.00
        Extra: Parallel scan (2 workers); Using index condition; Using where; Using temporary
*************************** 3. row ***************************
           id: 2
  select_type: DEPENDENT SUBQUERY
        table: lineitem
   partitions: NULL
         type: ref
possible_keys: PRIMARY,i_l_orderkey
          key: PRIMARY
      key_len: 4
          ref: tpch_10.orders.O_ORDERKEY
         rows: 4
     filtered: 33.3
        Extra: Parallel pushdown; Using where
3 rows in set, 2 warnings (0.01 sec)

3. Satırda Extra: Parallel pushdown ile birlikte select_type: DEPENDENT SUBQUERY bulunur. Bu, alt sorgunun koordinatörde bir kez değerlendirilmek yerine, paralel çalıştırma için her bir worker'a itildiği anlamına gelir.

PolarDB for MySQL 8.0.2: EXPLAIN FORMAT=TREE

Örnek 1

EXPLAIN FORMAT=TREE SELECT
    o_orderpriority,
    COUNT(*) as order_count
FROM
    orders
WHERE
    o_orderdate >= '1994-04-01'
    AND o_orderdate < date_add('1994-04-01', interval '3' month)
    AND exists (
        SELECT
            *
        FROM
            lineitem
        WHERE
            l_orderkey = o_orderkey
            and l_commitdate < l_receiptdate
    )
GROUP BY
    o_orderpriority
ORDER BY
    o_orderpriority\G
*************************** 1. row ***************************
EXPLAIN: -> Sort: <temporary>.o_orderpriority
    -> Table scan on <temporary>
        -> Aggregate using temporary table  (cost=1746887.76 rows=1489068)
            -> Gather (slice: 1; workers: 2)  (cost=1597980.96 rows=1489068)
                -> Table scan on <temporary>
                    -> Aggregate using temporary table  (cost=1486290.85 rows=744534)
                        -> Filter: exists(select #2)  (cost=772982.43 rows=568369)
                            -> Parallel index range scan on orders using i_o_orderdate, with index condition: ((orders.O_ORDERDATE >= DATE'1994-04-01') and (orders.O_ORDERDATE < <cache>(('1994-04-01' + interval '3' month)))), with parallel partitions: 89  (cost=772982.43 rows=568369)
                            -> Select #2 (subquery in condition; dependent)
                                -> Limit: 1 row(s)
                                    -> Filter: (lineitem.L_COMMITDATE < lineitem.L_RECEIPTDATE)  (cost=1.14 rows=1)
                                        -> Index lookup on lineitem using PRIMARY (L_ORDERKEY=orders.O_ORDERKEY)  (cost=1.14 rows=4)

1 row in set, 1 warning (0.02 sec)

Gather (slice: 1; workers: 2) düğümü, paralel alt ağacı (aşağıda) seri toplama ve sıralamadan (yukarıda) ayırır. Alt sorgu (Select #2), dependent olarak işaretlenmiştir; yani Parallel pushdown olarak her worker içinde çalışır.

Örnek 2

EXPLAIN FORMAT=TREE
select
    ps_partkey,
    sum(ps_supplycost * ps_availqty) as value
from
    partsupp,
    supplier,
    nation
where
    ps_suppkey = s_suppkey
    and s_nationkey = n_nationkey
    and n_name = 'IRAN'
group by
    ps_partkey having
        sum(ps_supplycost * ps_availqty) > (
            select
                sum(ps_supplycost * ps_availqty) * 0.0000010000
            from
                partsupp,
                supplier,
                nation
            where
                ps_suppkey = s_suppkey
                and s_nationkey = n_nationkey
                and n_name = 'IRAN'
        )
order by
    value desc limit 1;
| -> Limit: 1 row(s)  (cost=1408498.03 rows=1)
    -> Gather (merge sort; slice: 1; workers: 256; actual workers: 32)  (cost=1408498.03 rows=256)
        -> Limit: 1 row(s)  (cost=1408404.20 rows=1)
            -> Sort: <temporary>.value DESC, limit input to 1 row(s) per chunk  (cost=1408404.20 rows=803182)
                -> Filter: (sum((partsupp.PS_SUPPLYCOST * partsupp.PS_AVAILQTY)) > (select #2))
                    -> Table scan on <temporary>
                        -> Aggregate using temporary table  (cost=1408404.20 rows=803182)
                            -> Inner hash join (partsupp.PS_SUPPKEY = supplier.S_SUPPKEY)  (cost=829770.18 rows=327820)
                                -> Parallel table scan on partsupp, with parallel partitions: 2882, partition_keys: 1  (cost=6347528.15 rows=3176912)
                                -> Hash
                                    -> Broadcast (slice: 2; workers: 256; nodes: 16)  (cost=103382.56 rows=1029632)
                                        -> Nested loop inner join  (cost=409.36 rows=4022)
                                            -> Filter: (nation.N_NAME = 'IRAN')  (cost=2.29 rows=3)
                                                -> Table scan on nation  (cost=2.29 rows=25)
                                            -> Parallel index lookup on supplier using SUPPLIER_FK1 (S_NATIONKEY=nation.N_NATIONKEY), with parallel partitions: 9243  (cost=65.94 rows=1609)
                    -> Select #2 (subquery in condition; run only once; shared access)
                        -> Aggregate: sum(`<collector>`.tmp_field_0)  (cost=825576.85 rows=1)
                            -> Gather (slice: 1; workers: 256; nodes: 16)  (cost=825564.05 rows=256)
                                -> Aggregate: sum((partsupp.PS_SUPPLYCOST * partsupp.PS_AVAILQTY))  (cost=825541.20 rows=1)
                                    -> Inner hash join (partsupp.PS_SUPPKEY = supplier.S_SUPPKEY)  (cost=809150.20 rows=327820)
                                        -> Parallel table scan on partsupp, with parallel partitions: 14405  (cost=6147699.35 rows=3176912)
                                        -> Hash
                                            -> Broadcast (slice: 2; workers: 256; nodes: 16)  (cost=103382.56 rows=1029632)
                                                -> Nested loop inner join  (cost=409.36 rows=4022)
                                                    -> Filter: (nation.N_NAME = 'IRAN')  (cost=2.29 rows=3)
                                                        -> Table scan on nation  (cost=2.29 rows=25)
                                                    -> Parallel index lookup on supplier using SUPPLIER_FK1 (S_NATIONKEY=nation.N_NATIONKEY), with parallel partitions: 9243  (cost=65.94 rows=1609)

Bu plandaki önemli noktalar şunlardır:

  • Gather (merge sort; slice: 1; workers: 256; actual workers: 32) — merge sort değiştiricisi, Gather düğümünün worker'lardan önceden sıralanmış sonuçları birleştirdiğini ve en üst düzeyde tam bir yeniden sıralamadan kaçındığını gösterir. workers: 256 yapılandırılmış paralellik derecesidir; actual workers: 32 ise gerçekten çalışan worker sayısıdır.

  • Select #2 (subquery in condition; run only once; shared access) — HAVING alt sorgusu paralel olarak bir kez çalıştırılır ve sonuç tüm dış worker'lar arasında paylaşılır. Bu, Shared access optimizasyonudur.

  • Broadcast (slice: 2; workers: 256; nodes: 16) — supplier ve nation birleştirme sonucunu, her düğümün çapraz düğüm veri hareketi olmadan yerel olarak karma birleştirmesini gerçekleştirebilmesi için 16 düğümün tamamına gönderir.

  • Dış sorgu bloğu, ilke kısıtlamaları nedeniyle çok düğümlü esnek paralel sorguyu kullanamaz. Dış sorgu için worker'lar, sorgunun teslim edildiği düğümde tek düğümlü esnek paralel sorgu çalıştırır.

EXPLAIN ANALYZE ile worker başına çalıştırma süresini görüntüleyin

PolarDB for MySQL 8.0.2'de kullanılabilen EXPLAIN ANALYZE komutu, tahmini maliyetin yanı sıra gerçek zamanlama bilgisi ekler. Paralel sorgular için, maksimum, minimum ve tüm worker'lar ortalaması dahil olmak üzere her bir işleç için her worker'ın çalıştırma süresini kaydeder.

EXPLAIN ANALYZE select
    c_name,
    c_custkey,
    o_orderkey,
    o_orderdate,
    o_totalprice,
    sum(l_quantity)
from
    customer,
    orders,
    lineitem
where
    o_orderkey in (
        select
            l_orderkey
        from
            lineitem
        group by
            l_orderkey having
                sum(l_quantity) > 313
    )
    and c_custkey = o_custkey
    and o_orderkey = l_orderkey
group by
    c_name,
    c_custkey,
    o_orderkey,
    o_orderdate,
    o_totalprice
order by
    o_totalprice desc,
    o_orderdate
LIMIT 100;
| -> Limit: 100 row(s)  (cost=14.62 rows=1) (actual time=1.252..1.252 rows=0 loops=1)
    -> Gather (merge sort; slice: 1; workers: 1; nodes: 2)  (cost=14.62 rows=1) (actual time=1.250..1.250 rows=0 loops=1)
        -> Limit: 100 row(s)  (cost=4.52 rows=1) (actual time=0.084,0.084,0.084..0.084,0.084,0.084 rows=0,0,0 loops=1,1,1)
            -> Sort: <temporary>.O_TOTALPRICE DESC, <temporary>.O_ORDERDATE, limit input to 100 row(s) per chunk  (cost=4.52 rows=1) (actual time=0.083,0.083,0.083..0.083,0.083,0.083 rows=0,0,0 loops=1,1,1)
                -> Table scan on <temporary> (actual time=0.070,0.070,0.070..0.070,0.070,0.070 rows=0,0,0 loops=1,1,1)
                    -> Aggregate using temporary table  (cost=4.52 rows=1) (actual time=0.001,0.001,0.001..0.001,0.001,0.001 rows=0,0,0 loops=1,1,1)
                        -> Nested loop inner join  (cost=2.86 rows=4) (actual time=0.039,0.039,0.039..0.039,0.039,0.039 rows=0,0,0 loops=1,1,1)
                            -> Nested loop inner join  (cost=1.45 rows=1) (actual time=0.037,0.037,0.037..0.037,0.037,0.037 rows=0,0,0 loops=1,1,1)
                                -> Parallel table scan on customer, with parallel partitions: 1, partition_keys: 1  (cost=0.35 rows=1) (actual time=0.036,0.036,0.036..0.036,0.036,0.036 rows=0,0,0 loops=1,1,1)
                                -> Filter: <in_optimizer>(orders.O_ORDERKEY,<exists>(select #2))  (cost=1.10 rows=1)
                                    -> Index lookup on orders using ORDERS_FK1 (O_CUSTKEY=customer.C_CUSTKEY)  (cost=1.10 rows=1)
                                    -> Select #2 (subquery in condition; dependent)
                                        -> Limit: 1 row(s)
                                            -> Filter: ((sum(lineitem.L_QUANTITY) > 313) and (<cache>(orders.O_ORDERKEY) = <ref_null_helper>(lineitem.L_ORDERKEY)))
                                                -> Group aggregate: sum(lineitem.L_QUANTITY)
                                                    -> Index scan on lineitem using PRIMARY  (cost=41554048.20 rows=380071042)
                            -> Index lookup on lineitem using PRIMARY (L_ORDERKEY=orders.O_ORDERKEY)  (cost=1.41 rows=4)

actual time formatı, bir işlecin Gather düğümünün üzerinde mi yoksa altında mı çalıştığına bağlı olarak değişir:

İşleç konumu Format Örnek
Gather üzerinde (koordinatör, seri) actual time=start..end rows=N loops=N actual time=1.250..1.250 rows=0 loops=1
Gather altında (worker'lar, paralel) actual time=v1,v2,v3..v1,v2,v3 rows=N1,N2,N3 loops=N1,N2,N3 actual time=0.084,0.084,0.084..0.084,0.084,0.084 rows=0,0,0 loops=1,1,1

Paralel alt ağaçtaki işleçler için, virgülle ayrılmış her değer bir worker'a karşılık gelir. Bu sayede, worker'lar arasında darboğaz olan işleci ve çalıştırma süresinin eşit dağılıp dağılmadığını belirleyebilirsiniz.