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ştirenGatherişlemidir. Bu satır paralel sınırı işaret eder; bunun altındaki her şey paralel olarak çalışır.Satır,
ExtraalanındaParallel scan (2 workers)ilepq_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 sortdeğ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: 256yapılandırılmış paralellik derecesidir;actual workers: 32ise 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 accessoptimizasyonudur.Broadcast (slice: 2; workers: 256; nodes: 16)—suppliervenationbirleş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.