แแแแแแแแ แแแ แแ แแชแแกแแ แแแก แแฅแแ แแแแ แ แแแ แแแ. แฌแแแแแก แแแแแแแแแแแจแ, แแแแแแแชแแแแ แแแ แแแแแฃแ แแ แแแแแแแแแ แจแแแแแฎแแแแก แแแแแชแแแแ แแแแแแจแ. แแฃ แแก แแ แแก แแแฎแกแแแแแแก แแแแฎแแแแ แชแฎแ แแแจแ แ แแแแแแแแ แแฌแแ แแแแ, แแก แฃแคแ แ แกแฌแ แแคแแ แแฃแจแแแแก แแ แแแแแ CPU-แก แแแแแงแแแแแแกแแก แแ PostgreSQL-แก แจแแฃแซแแแ แแแแก แแแแแแแแ 9.6 แแแ แกแแแแแ.
แแแ แแแแแฃแ แ แจแแแแแฎแแแก แคแฃแแฅแชแแแก แแแแแ แแแแก 3 แฌแแแ แแแกแญแแ แแ - แแแแแก แแแแแฌแแ แ แแแแแแฌแแ แแแแฎแแแแแก แจแแกแ แฃแแแแแก แกแฎแแแแแกแฎแแ แแขแแแแ. PostgreSQL 9.6-แแ แจแแแแแขแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ แแแแแก แจแแแแแแแ แแแกแแฃแแฏแแแแกแแแแแ. แจแแแแแแ แแแ แกแแแแจแ แแแ แแแแแฃแ แแ แกแ แฃแแแแแ แกแฎแแ แขแแแแก แแแแฎแแแแแแ.
แจแแแฆแฃแแแแแ
- แแ แฉแแ แแแ แแแ แแแแแฃแ แ แจแแกแ แฃแแแแ, แแฃ แงแแแแ แแแ แแแ แฃแแแ แแแแแแแแฃแแแ, แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ แกแฎแแ แแแแฎแแแแแแ แจแแแแแแแแ.
- แ แแช แแแแแแ แแ, แแแ แแแแแฃแ แ แแแแฃแจแแแแแ แแแฆแแแ WORK_MEM แแแแจแแแแแแแแแแ แแงแแแแแก แฃแแแ แแ แแแฎแกแแแ แแแแก - แงแแแแแ แฐแแจแ-แจแแแ แแแแ แแ แแแฎแแ แแกแฎแแแ แแแแแแแก work_mem แแแฎแกแแแ แแแแก.
- แแแแแแ แจแแงแแแแแแแก OLTP แแแแฎแแแแแแแก แแแฉแฅแแ แแแ แจแแฃแซแแแแแแแ แแแ แแแแแฃแ แ แจแแกแ แฃแแแแแ. แแ แแฃ แแแแฎแแแแ แแแแแ แฃแแแแก แแ แ แ แแแก, แแแ แแแแแฃแ แ แแแแฃแจแแแแแ แแฎแแแแ แจแแแแแแแแก แแแก.
- แแแแแแแแแ แแแก แฃแงแแแ แ TPC-H แกแแแ แแแแขแแชแแ แแแจแแแก แแแแแงแแแแแ. แจแแกแแซแแแ แแฅแแแแแ แแกแแแแกแ แแแแฎแแแแแแ แกแ แฃแแงแแคแแแ แแแ แแแแแฃแ แ แจแแกแ แฃแแแแแกแแแแก.
- แแฎแแแแ SELECT แแแแฎแแแแแแ แแ แแแแแแขแแก แฉแแแแขแแแก แแแ แแจแ แกแ แฃแแแแแ แแแ แแแแแฃแ แแ.
- แแแแฏแแ แกแฌแแ แ แแแแแฅแกแแ แแแ แฃแแแแแกแแ, แแแแ แ แแแ แแแแแฃแ แ แแแแแจแ แชแฎแ แแแแก แแแแแแแแแแ แฃแแ แกแแแแแ แแแ.
- แแแแฎแแแแแแแกแ แแ แแฃแ แกแแ แแแแก แแแแแฃแแแแ แแฎแแ แแแญแแ แแแ แแ แแ แแก.
- แคแแแฏแ แแก แคแฃแแฅแชแแแแ แแ แจแแแแแแแแ แแแแ แแแแก แคแฃแแฅแชแแแแ แแ แแ แแก แแแ แแแแแฃแ แ.
- แแฅแแแ แแแ แแคแแ แก แแแแฆแแแ I/O แแแขแแแ แแแแก แแ แแก.
- แแ แแ แกแแแแแก แแแ แแแแแฃแ แ แแแฎแแ แแกแฎแแแแก แแแแแ แแแแแแ. แแแแ แแ แแแแแแแแแก แแฅแแแ แแแแฎแแแแแแ แจแแแซแแแแ แจแแกแ แฃแแแแก แแแ แแแแแฃแ แแ แแแแแแ แ แแกแแแฅแขแจแ.
- แฉแแแแแชแแแแ CTE (WITH ...) แฉแแกแแฃแแ SELECT-แแ, แ แแแ แฉแแ แแแ แแแ แแแแแฃแ แ แแแแฃแจแแแแแ.
- แแแกแแแ แแฎแแ แแก แแแแแชแแแแ แจแแคแฃแแแ แฏแแ แแ แฃแญแแ แก แแฎแแ แก แแแ แแแแแฃแ แแแแฃแจแแแแแแก (แแแแ แแ แแแ แจแแแซแแแ!)
- แกแ แฃแแ แแแ แ แจแแแ แแแแ แแ แแ แแก แแฎแแ แแแญแแ แแแ.
- max_rows แแแจแแแก แแแ แแแแแฃแ แแแแฃแจแแแแแแก.
- แแฃ แจแแแแแฎแแแก แแฅแแก แคแฃแแฅแชแแ, แ แแแแแแช แแ แแ แแก แแแแแจแแฃแแ PARALLEL SAFE, แแก แแฅแแแแ แแ แแ แฎแ แแฎแแแแแ.
- SERIALIZABLE แขแ แแแแแฅแชแแแก แแแแแแชแแแก แแแแ แแแแแ แแแแก แแแ แแแแแฃแ แแแแฃแจแแแแแแก.
แกแแขแแกแขแ แแแ แแแ
PostgreSQL แแแแแแแแแ แแแ แชแแแแแแแแแ แจแแแแชแแ แแแแแแ TPC-H แกแแแ แแแแขแแชแแ แแแแฎแแแแแแแก แแแกแฃแฎแแก แแ แ. แฉแแแแขแแแ แแแ แแแแฉแแแ แแ แแ . แแก แแ แแก TPC-H แกแแแ แแแแขแแชแแ แแแจแแแก แแ แแแคแแชแแแแฃแ แ แแแแแงแแแแแ - แแ แ แแแแแชแแแแ แแแแแก แแ แแแแ แแขแฃแ แแก แจแแแแ แแแแกแแแแก.
- แฉแแแแขแแแ แแแ TPC-H_Tools_v2.17.3.zip (แแ แฃแคแ แ แแฎแแแ แแแ แกแแ) .
- แแแแแ แฅแแแแ makefile.suite to Makefile แแ แจแแชแแแแ แ แแแแ แช แแฅ แแฆแฌแแ แแแแ: . แจแแแแแแแแ แแแแ make แแ แซแแแแแแ.
- แแแแแชแแแแแแก แแแแแ แแ แแแ:
./dbgen -s 10แฅแแแแก 23 GB แแแแแชแแแแ แแแแแก. แแก แกแแแแแ แแกแแ แแแแกแแแแก, แ แแ แแแฎแแ แแแแกแฎแแแแแแ แแแ แแแแแฃแ แ แแ แแ แแแแ แแแแแฃแ แ แแแแฎแแแแแแแก แจแแกแ แฃแแแแแจแ. - แคแแแแแแแก แแแแแแ แขแแชแแ
tblะฒcsv ั forะธsed. - แกแแชแแแแก แแแแแแ แแแ
pg_tpchแแ แแแแแแแแ แแ แคแแแแแแcsvะฒpg_tpch/dss/data. - แจแแฅแแแแแ แแแแฎแแแแแแ แแ แซแแแแแแ
qgen. - แฉแแขแแแ แแแ แแแแแชแแแแแ แแแแแชแแแแ แแแแแจแ แแ แซแแแแแแ
./tpch.sh.
แแแ แแแแแฃแ แ แแแแแแแแแแ แฃแแ แกแแแแแ แแแ
แแก แจแแแซแแแแ แแงแแก แฃแคแ แ แกแฌแ แแคแ แแ แ แแแ แแแแแฃแ แ แฌแแแแแฎแแแก แแแแ, แแ แแแแ แแแแก แแแแ, แ แแ แแแแแชแแแแแ แแ แชแแแแแแ แแแแ CPU แแแ แแแแ. แแแแแแแแ แแแ แแแแ แแชแแฃแ แกแแกแขแแแแแจแ PostgreSQL แแแแแชแแแแ แคแแแแแแ แแแ แแแ แแ แแก แจแแแแฎแฃแแ. แฌแแแแกแฌแแ แ แฌแแแแแฎแแแ, แจแแกแแซแแแแแแแ แกแแชแแแแแแ แฃแคแ แ แแแแ แแแแแแก แแแฆแแแ, แแแแ แ PG แแแแแแ แแแฎแแแก. แแแแขแแ, แจแแแแแฎแแแก แจแแกแ แฃแแแแ แแ แจแแแแแคแแ แแแแแ แแแกแแแก I/O-แแ. แแก แแแแฎแแแ แก CPU แชแแแแแแก:
- แฌแแแแแแฎแแ แ แแแแแ แแแแ-แแแแ แชแฎแ แแแแก แแแแ แแแแแแแ;
- แจแแแแแ แแ แกแแแแแแแแ แแแแจแแแแแแแแแ แแ แแแ แแแแแ
WHERE.
แแแแแ แแแแฃแจแแแ แแแ แขแแแ แจแแแแแฎแแ select:
tpch=# explain analyze select l_quantity as sum_qty from lineitem where l_shipdate <= date '1998-12-01' - interval '105' day;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------
Seq Scan on lineitem (cost=0.00..1964772.00 rows=58856235 width=5) (actual time=0.014..16951.669 rows=58839715 loops=1)
Filter: (l_shipdate <= '1998-08-18 00:00:00'::timestamp without time zone)
Rows Removed by Filter: 1146337
Planning Time: 0.203 ms
Execution Time: 19035.100 msแแแแแแแแแแ แฃแแ แกแแแแแ แแแ แฌแแ แแแฅแแแแก แซแแแแแ แแแแ แแฌแแ แแแก แแแ แแแแชแแแก แแแ แแจแ, แแแแขแแ แแแแฎแแแแ แจแแกแ แฃแแแแฃแแแ แแ แแ CPU แแแ แแแแ.
แแฃ แแแแแแขแแ SUM(), แฎแแแแแ, แ แแ แแ แ แกแแแฃแจแแ แแ แแชแแกแ แแแแแฎแแแ แแแแ แแแแฉแฅแแ แแก แจแแแแแฎแแ:
explain analyze select sum(l_quantity) as sum_qty from lineitem where l_shipdate <= date '1998-12-01' - interval '105' day;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------
Finalize Aggregate (cost=1589702.14..1589702.15 rows=1 width=32) (actual time=8553.365..8553.365 rows=1 loops=1)
-> Gather (cost=1589701.91..1589702.12 rows=2 width=32) (actual time=8553.241..8555.067 rows=3 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Partial Aggregate (cost=1588701.91..1588701.92 rows=1 width=32) (actual time=8547.546..8547.546 rows=1 loops=3)
-> Parallel Seq Scan on lineitem (cost=0.00..1527393.33 rows=24523431 width=5) (actual time=0.038..5998.417 rows=19613238 loops=3)
Filter: (l_shipdate <= '1998-08-18 00:00:00'::timestamp without time zone)
Rows Removed by Filter: 382112
Planning Time: 0.241 ms
Execution Time: 8555.131 msแแแ แแแแแฃแ แ แแแ แแแแชแแ
แแแ แแแแแฃแ แ Seq Scan แแแแแซแ แแฌแแ แแแแแก แ แแแแแก แแแฌแแแแแ แแแ แแแ แแแแชแแแกแแแแก. "แแแ แชแแแแฃแ แ แแแ แแแแขแ" แแแแแซแ แแ แฎแแแแแก แญแ แแก SUM(). แแแกแแกแ แฃแแก, SUM แแ แแชแฎแแแแ แแแแแแฃแแ แแฃแจแ แแ แแชแแกแแแแ แแ แแแแแแ แแแแแซแแก แแแแ .
แกแแแแแแ แจแแแแแ แแแแแแแแแแแ "Finalize Aggregate" แแแแแซแแ. แแฃ แแฅแแแ แแแฅแแ แกแแแฃแแแ แ แแแ แแแแชแแแก แคแฃแแฅแชแแแแ, แแ แแแแแแแฌแงแแแ แแแแแจแแแ แแกแแแ, แ แแแแ แช โแแแ แแแแแฃแ แ แฃแกแแคแ แแฎแโ.
แแฃแจแแแ แแ แแชแแกแแแแก แ แแแแแแแแ
แแฃแจแ แแ แแชแแกแแแแก แ แแแแแแแแ แจแแแซแแแแ แแแแแแ แแแก แกแแ แแแ แแก แแแแแขแแแ แแแแก แแแ แแจแ:
explain analyze select sum(l_quantity) as sum_qty from lineitem where l_shipdate <= date '1998-12-01' - interval '105' day;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------
Finalize Aggregate (cost=1589702.14..1589702.15 rows=1 width=32) (actual time=8553.365..8553.365 rows=1 loops=1)
-> Gather (cost=1589701.91..1589702.12 rows=2 width=32) (actual time=8553.241..8555.067 rows=3 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Partial Aggregate (cost=1588701.91..1588701.92 rows=1 width=32) (actual time=8547.546..8547.546 rows=1 loops=3)
-> Parallel Seq Scan on lineitem (cost=0.00..1527393.33 rows=24523431 width=5) (actual time=0.038..5998.417 rows=19613238 loops=3)
Filter: (l_shipdate <= '1998-08-18 00:00:00'::timestamp without time zone)
Rows Removed by Filter: 382112
Planning Time: 0.241 ms
Execution Time: 8555.131 msแฒ แ แฎแแแแ แแฅ? แแงแ 2-แฏแแ แแแขแ แกแแแฃแจแแ แแ แแชแแกแ, แแแแฎแแแแ แแ แแฎแแแแ 1,6599-แฏแแ แฃแคแ แ แกแฌแ แแคแ แแแฎแแ. แแแแแแแแ แกแแแแขแแ แแกแแ. แแแงแแแแ 2 แแฃแจแ แแ แแชแแกแ แแ 1 แแแแแ แ. แชแแแแแแแแก แจแแแแแ แแแฎแแ 4+1.
แฉแแแแ แแแฅแกแแแแแฃแ แ แกแแฉแฅแแ แ แแแ แแแแแฃแ แ แแแแฃแจแแแแแแกแแแ: 5/3 = 1,66(6) แฏแแ .
แ แแแแ แแฃแจแแแแก แแแ?
ะัะพัะตััั
แแแแฎแแแแแก แจแแกแ แฃแแแแ แงแแแแแแแแก แแฌแงแแแ แฌแแแงแแแแ แแ แแชแแกแแ. แแแแแ แ แแแแแแแก แงแแแแแคแแ แก แแ แแแแ แแแแแฃแ แแ แแ แ แแฆแแช แแแ แแแแแฃแ แแ แแแแฃแจแแแแแแก. แกแฎแแ แแ แแชแแกแแแก, แ แแแแแแแช แแกแ แฃแแแแแ แแแแแ แแแแฎแแแแแแก, แแฌแแแแแ แแฃแจแ แแ แแชแแกแแแ. แแแ แแแแแฃแ แ แแแแฃแจแแแแแ แแงแแแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก (9.4 แแแ แกแแแแแ). แแแแแแแแ PostgreSQL-แแก แกแฎแแ แแแฌแแแแแ แแงแแแแแก แแ แแชแแกแแแก แแ แแ แ แซแแคแแแก, แแแแฎแแแแ 3 แแฃแจแ แแ แแชแแกแแ แจแแแซแแแแ แแงแแก 4-แฏแแ แฃแคแ แ แกแฌแ แแคแ แแแแ แ แขแ แแแแชแแฃแแ แแแแฃแจแแแแแ.
แฃแ แแแแ แแฅแแแแแแ
แแฃแจแแแ แแ แแชแแกแแแ แแแแแ แแแ แฃแ แแแแ แแแแก แจแแขแงแแแแแแแแแแก แ แแแแก แแแจแแแแแแ (แแแแแแ แแแฃแแ แแแฎแกแแแ แแแแก แกแแคแฃแซแแแแแ). แแแแแแฃแ แแ แแชแแกแก แแฅแแก 2 แ แแแแแ: แจแแชแแแแแแแกแแแแก แแ แขแแแแแแกแแแแก.
แ แแแแแแ แกแแแฃแจแแ แแ แแชแแกแแ แกแแญแแ แ?
แแแแแแแแฃแ แ แแแแแขแ แแแแแแแแฃแแแ แแแ แแแแขแ แแ . แแแแฎแแแแแก แแแแจแแแแ แจแแแแแ แแฆแแแก แแฃแจแ แแ แแชแแกแแแก แแแ แแแแขแ แแ แจแแแฆแฃแแฃแแ แแฃแแแแแ . แแแแ แจแแแฆแฃแแแ แแ แแก , แแแฃ แคแแแฃแ แ แแ แแชแแกแแแแก แกแแแ แแ แ แแแแแแแแ.
แแฃ แแแ แแแฎแแ แฎแแ แแฃแจแ แแ แแชแแกแแก แแแแแงแแคแ, แแแแฃแจแแแแแ แแฅแแแแ แแ แแแ แแชแแกแแแแ.
แจแแแแแฎแแแก แแแแแแแแแแแ แจแแแซแแแแ แจแแแแชแแ แแก แกแแแฃแจแแ แแแแแแแแ แชแฎแ แแแแก แแ แแแแแฅแกแแก แแแแแก แแแฎแแแแแ. แแแแกแแแแแก แแ แแก แแแ แแแแขแ แแแ ะธ .
set min_parallel_table_scan_size='8MB'
8MB table => 1 worker
24MB table => 2 workers
72MB table => 3 workers
x => log(x / min_parallel_table_scan_size) / log(3) + 1 workerแงแแแแ แฏแแ แแ แแแแแแ 3-แฏแแ แแแขแแ แแแแ แ min_parallel_(index|table)_scan_size, Postgres แแแแขแแแก แแฃแจแ แแ แแชแแกแก. แกแแแฃแจแแ แแแแแแแแแก แ แแแแแแแแ แแ แแ แแก แแแคแฃแซแแแแฃแแ แฎแแ แฏแแแแ. แฌแ แแฃแแ แแแแแแแแแแฃแแแแ แแ แแฃแแแแก แแแแแแแฅแกแฃแ แแแแฎแแ แชแแแแแแแก. แแแแก แแแชแแแแ, แแแแแแแแแแ แแงแแแแแก แแแ แขแแ แฌแแกแแแก.
แแ แแฅแขแแแแจแ, แแก แฌแแกแแแ แงแแแแแแแแก แแ แแ แแก แจแแกแแคแแ แแกแ แฌแแ แแแแแแกแแแแก, แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แจแแชแแแแแ แกแแแฃแจแแ แแ แแชแแกแแแแก แ แแแแแแแแ แแแแแ แแขแฃแแ แชแฎแ แแแแกแแแแก: ALTER TABLE ... SET (parallel_workers = N).
แ แแขแแ แแ แแแแแแงแแแแแ แแแ แแแแแฃแ แ แแแแฃแจแแแแแ?
แจแแแฆแฃแแแแแแก แแ แซแแแ แกแแแก แแแ แแ, แแกแแแ แแ แกแแแแแก แฎแแ แฏแแแแก แจแแแแฌแแแแ:
- แแแแแ แแแแฎแแแแแแแก แแแ แแแแแฃแ แ แแแแฃแจแแแแแแก แแแแแแแ แแกแแชแแแแแแแ. แแก แแแ แแแแขแ แ แแคแแกแแแก แแแฎแกแแแ แแแแก แแแแแแแแแแก, แแ แแชแแกแแก แแแฌแงแแแแก แแ แแแแแชแแแแ แกแแฌแงแแกแ แแแชแแแแก แแ แแก.
: แแแแแ แกแ แแ แแฃแจแแแแแก แจแแ แแก แแแแฃแแแแแชแแ แจแแแซแแแแ แจแแคแแ แฎแแแก แกแแแฃแจแแ แแ แแชแแกแแแแแแ แขแแแแแแก แ แแแแแแแแแก แแ แแแแ แชแแฃแแแ. แแก แแแ แแแแขแ แ แแแแแแก แแแแแชแแแแ แแแชแแแแก แฆแแ แแแฃแแแแแก.
แฉแแแแแฃแแ แแแ แงแฃแแแก แฃแแ แแแแแ
PostgreSQL 9.6+ ะผะพะถะตั ะฒัะฟะพะปะฝััั ะฒะปะพะถะตะฝะฝัะต ัะธะบะปั ะฟะฐัะฐะปะปะตะปัะฝะพ โ ััะพ ะฟัะพััะฐั ะพะฟะตัะฐัะธั.
explain (costs off) select c_custkey, count(o_orderkey)
from customer left outer join orders on
c_custkey = o_custkey and o_comment not like '%special%deposits%'
group by c_custkey;
QUERY PLAN
--------------------------------------------------------------------------------------
Finalize GroupAggregate
Group Key: customer.c_custkey
-> Gather Merge
Workers Planned: 4
-> Partial GroupAggregate
Group Key: customer.c_custkey
-> Nested Loop Left Join
-> Parallel Index Only Scan using customer_pkey on customer
-> Index Scan using idx_orders_custkey on orders
Index Cond: (customer.c_custkey = o_custkey)
Filter: ((o_comment)::text !~~ '%special%deposits%'::text)แจแแแ แแแแแ แฎแแแแ แแแแ แแขแแแแ, แแแแขแแ Nested Loop Left Join แแ แแก แแแ แแแแแฃแ แ แแแแ แแชแแ. Parallel Index Only Scan แแแแแแ แแ แแฎแแแแ 10 แแแ แกแแแจแ. แแก แแฃแจแแแแก แแแ แแแแแฃแ แ แกแแ แแฃแแ แกแแแแแ แแแแก แแกแแแแกแแ. แแแแแแแ แแแแ c_custkey = o_custkey แแแแฎแฃแแแแก แแ แ แจแแแแแแแก แแแแแแขแแก แกแขแ แแฅแแแแ. แแกแ แ แแ แแ แแ แแก แแแ แแแแแฃแ แ.
Hash Join
แแแแแแฃแแ แแฃแจแ แแ แแชแแกแ แฅแแแแก แกแแแฃแแแ แฐแแจแแก แชแฎแ แแแก PostgreSQL 11-แแแ. แแ แแฃ แแ แแ แแชแแกแแแแแแ แแแฎแแ แแแขแ แแฅแแแแ, แจแแกแ แฃแแแแ แแ แแแฃแแฏแแแแกแแแแ. แแฎแแ แแแ แกแแแจแ แฐแแจแแก แชแฎแ แแแ แแแแแแ แแแฃแแแ. แแแแแแฃแ แแฃแจแ แแ แแชแแกแก แจแแฃแซแแแ แแแแแแงแแแแก WORK_MEM แฐแแจแแก แชแฎแ แแแแก แจแแกแแฅแแแแแแ.
select
l_shipmode,
sum(case
when o_orderpriority = '1-URGENT'
or o_orderpriority = '2-HIGH'
then 1
else 0
end) as high_line_count,
sum(case
when o_orderpriority <> '1-URGENT'
and o_orderpriority <> '2-HIGH'
then 1
else 0
end) as low_line_count
from
orders,
lineitem
where
o_orderkey = l_orderkey
and l_shipmode in ('MAIL', 'AIR')
and l_commitdate < l_receiptdate
and l_shipdate < l_commitdate
and l_receiptdate >= date '1996-01-01'
and l_receiptdate < date '1996-01-01' + interval '1' year
group by
l_shipmode
order by
l_shipmode
LIMIT 1;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=1964755.66..1964961.44 rows=1 width=27) (actual time=7579.592..7922.997 rows=1 loops=1)
-> Finalize GroupAggregate (cost=1964755.66..1966196.11 rows=7 width=27) (actual time=7579.590..7579.591 rows=1 loops=1)
Group Key: lineitem.l_shipmode
-> Gather Merge (cost=1964755.66..1966195.83 rows=28 width=27) (actual time=7559.593..7922.319 rows=6 loops=1)
Workers Planned: 4
Workers Launched: 4
-> Partial GroupAggregate (cost=1963755.61..1965192.44 rows=7 width=27) (actual time=7548.103..7564.592 rows=2 loops=5)
Group Key: lineitem.l_shipmode
-> Sort (cost=1963755.61..1963935.20 rows=71838 width=27) (actual time=7530.280..7539.688 rows=62519 loops=5)
Sort Key: lineitem.l_shipmode
Sort Method: external merge Disk: 2304kB
Worker 0: Sort Method: external merge Disk: 2064kB
Worker 1: Sort Method: external merge Disk: 2384kB
Worker 2: Sort Method: external merge Disk: 2264kB
Worker 3: Sort Method: external merge Disk: 2336kB
-> Parallel Hash Join (cost=382571.01..1957960.99 rows=71838 width=27) (actual time=7036.917..7499.692 rows=62519 loops=5)
Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
-> Parallel Seq Scan on lineitem (cost=0.00..1552386.40 rows=71838 width=19) (actual time=0.583..4901.063 rows=62519 loops=5)
Filter: ((l_shipmode = ANY ('{MAIL,AIR}'::bpchar[])) AND (l_commitdate < l_receiptdate) AND (l_shipdate < l_commitdate) AND (l_receiptdate >= '1996-01-01'::date) AND (l_receiptdate < '1997-01-01 00:00:00'::timestamp without time zone))
Rows Removed by Filter: 11934691
-> Parallel Hash (cost=313722.45..313722.45 rows=3750045 width=20) (actual time=2011.518..2011.518 rows=3000000 loops=5)
Buckets: 65536 Batches: 256 Memory Usage: 3840kB
-> Parallel Seq Scan on orders (cost=0.00..313722.45 rows=3750045 width=20) (actual time=0.029..995.948 rows=3000000 loops=5)
Planning Time: 0.977 ms
Execution Time: 7923.770 msแแแแฎแแแแ 12 TPC-H-แแแ แแแแแแ แแฉแแแแแแก แแแ แแแแแฃแ แฐแแจแแก แแแแจแแ แก. แแแแแแฃแแ แแฃแจแ แแ แแชแแกแ แฎแแแก แฃแฌแงแแแก แกแแแ แแ แฐแแจแแก แชแฎแ แแแแก แจแแฅแแแแก.
แจแแ แฌแงแแ แแแฌแแแ แแแแแแ
แจแแ แฌแงแแแก แจแแแ แแแแ แแฃแแแแแ แแ แแแแ แแแแแฃแ แแ. แแ แแแแ แแแฃแแแ, แแฃ แแก แแ แแก แแแแฎแแแแแก แแแแ แแแแแฏแ - แแก แแแแแช แจแแแซแแแแ แแแ แแแแแฃแ แแ แแแฃแจแแแก.
-- Query 2 from TPC-H
explain (costs off) select s_acctbal, s_name, n_name, p_partkey, p_mfgr, s_address, s_phone, s_comment
from part, supplier, partsupp, nation, region
where
p_partkey = ps_partkey
and s_suppkey = ps_suppkey
and p_size = 36
and p_type like '%BRASS'
and s_nationkey = n_nationkey
and n_regionkey = r_regionkey
and r_name = 'AMERICA'
and ps_supplycost = (
select
min(ps_supplycost)
from partsupp, supplier, nation, region
where
p_partkey = ps_partkey
and s_suppkey = ps_suppkey
and s_nationkey = n_nationkey
and n_regionkey = r_regionkey
and r_name = 'AMERICA'
)
order by s_acctbal desc, n_name, s_name, p_partkey
LIMIT 100;
QUERY PLAN
----------------------------------------------------------------------------------------------------------
Limit
-> Sort
Sort Key: supplier.s_acctbal DESC, nation.n_name, supplier.s_name, part.p_partkey
-> Merge Join
Merge Cond: (part.p_partkey = partsupp.ps_partkey)
Join Filter: (partsupp.ps_supplycost = (SubPlan 1))
-> Gather Merge
Workers Planned: 4
-> Parallel Index Scan using <strong>part_pkey</strong> on part
Filter: (((p_type)::text ~~ '%BRASS'::text) AND (p_size = 36))
-> Materialize
-> Sort
Sort Key: partsupp.ps_partkey
-> Nested Loop
-> Nested Loop
Join Filter: (nation.n_regionkey = region.r_regionkey)
-> Seq Scan on region
Filter: (r_name = 'AMERICA'::bpchar)
-> Hash Join
Hash Cond: (supplier.s_nationkey = nation.n_nationkey)
-> Seq Scan on supplier
-> Hash
-> Seq Scan on nation
-> Index Scan using idx_partsupp_suppkey on partsupp
Index Cond: (ps_suppkey = supplier.s_suppkey)
SubPlan 1
-> Aggregate
-> Nested Loop
Join Filter: (nation_1.n_regionkey = region_1.r_regionkey)
-> Seq Scan on region region_1
Filter: (r_name = 'AMERICA'::bpchar)
-> Nested Loop
-> Nested Loop
-> Index Scan using idx_partsupp_partkey on partsupp partsupp_1
Index Cond: (part.p_partkey = ps_partkey)
-> Index Scan using supplier_pkey on supplier supplier_1
Index Cond: (s_suppkey = partsupp_1.ps_suppkey)
-> Index Scan using nation_pkey on nation nation_1
Index Cond: (n_nationkey = supplier_1.s_nationkey)"Merge Join" แแแแแซแ แแแแแแ แแแแก "Gather Merge"-แแก แแแแแ. แแกแ แ แแ, แจแแ แฌแงแแ แแ แแงแแแแแก แแแ แแแแแฃแ แแแแฃแจแแแแแแก. แแแแ แแ "แแแ แแแแแฃแ แ แแแแแฅแกแแก แกแแแแแ แแแ" แแแแแซแ แแแแแช แแฎแแแ แแแ แกแแแแแแขแก part_pkey.
แแแแจแแ แ แกแแฅแชแแแแแ
PostgreSQL 11-แจแ แแแแฃแแแกแฎแแแแแ แแแแแ แแฃแแแ: แแแก แแฅแแก แซแแแแแ แซแแแ แ แแแแแแแแ. แแกแแแแกแ แแแแแงแแคแแก แแฅแแแ แชแฎแ แแแแแ แจแแแซแแแแ แจแแฃแแ แแแแก แแแแแงแแคแ แแแแแงแแคแแแแ. แแ แแแแ Postgres แแแแแแงแแแแแก แฃแคแ แ แแแขแแ แ แฐแแจ แชแฎแ แแแแแก. แกแแฅแชแแแแแก แแแแแแฃแแ แแแแจแแ แ แจแแแซแแแแ แแงแแก แแแ แแแแแฃแ แ.
tpch=# set enable_partitionwise_join=t;
tpch=# explain (costs off) select * from prt1 t1, prt2 t2
where t1.a = t2.b and t1.b = 0 and t2.b between 0 and 10000;
QUERY PLAN
---------------------------------------------------
Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Seq Scan on prt2_p1 t2
Filter: ((b >= 0) AND (b <= 10000))
-> Hash
-> Seq Scan on prt1_p1 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
-> Seq Scan on prt2_p2 t2_1
Filter: ((b >= 0) AND (b <= 10000))
-> Hash
-> Seq Scan on prt1_p2 t1_1
Filter: (b = 0)
tpch=# set parallel_setup_cost = 1;
tpch=# set parallel_tuple_cost = 0.01;
tpch=# explain (costs off) select * from prt1 t1, prt2 t2
where t1.a = t2.b and t1.b = 0 and t2.b between 0 and 10000;
QUERY PLAN
-----------------------------------------------------------
Gather
Workers Planned: 4
-> Parallel Append
-> Parallel Hash Join
Hash Cond: (t2_1.b = t1_1.a)
-> Parallel Seq Scan on prt2_p2 t2_1
Filter: ((b >= 0) AND (b <= 10000))
-> Parallel Hash
-> Parallel Seq Scan on prt1_p2 t1_1
Filter: (b = 0)
-> Parallel Hash Join
Hash Cond: (t2.b = t1.a)
-> Parallel Seq Scan on prt2_p1 t2
Filter: ((b >= 0) AND (b <= 10000))
-> Parallel Hash
-> Parallel Seq Scan on prt1_p1 t1
Filter: (b = 0)แแแแแแ แ แแก แแ แแก, แ แแ แกแแฅแชแแแแจแ แแแแจแแ แ แแแ แแแแแฃแ แแ แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ แแก แกแแฅแชแแแแ แกแแแแแ แแกแแ แแแแแ.
แแแ แแแแแฃแ แ แแแแแ แแ
แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แกแฎแแแแแกแฎแแ แแแแแแก แแแชแแแแ แกแฎแแแแแกแฎแแ แกแแแฃแจแแ แแ แแชแแกแแแจแ. แแก แฉแแแฃแแแแ แแ แฎแแแแ UNION ALL แแแแฎแแแแแแแก แจแแแแฎแแแแแจแ. แแแแฃแกแ แแ แแก แแแแแแแ แแแ แแแแแแแแ, แ แแแแแ แแแแแแฃแแ แแฃแจแ แแ แแชแแกแ แแแฃแจแแแแแก แแฎแแแแ 1 แแแแฎแแแแแก.
แแฅ แแฃแจแแแแก 2 แแฃแจแ แแ แแชแแกแ, แแฃแแชแ 4 แฉแแ แแฃแแแ.
tpch=# explain (costs off) select sum(l_quantity) as sum_qty from lineitem where l_shipdate <= date '1998-12-01' - interval '105' day union all select sum(l_quantity) as sum_qty from lineitem where l_shipdate <= date '2000-12-01' - interval '105' day;
QUERY PLAN
------------------------------------------------------------------------------------------------
Gather
Workers Planned: 2
-> Parallel Append
-> Aggregate
-> Seq Scan on lineitem
Filter: (l_shipdate <= '2000-08-18 00:00:00'::timestamp without time zone)
-> Aggregate
-> Seq Scan on lineitem lineitem_1
Filter: (l_shipdate <= '1998-08-18 00:00:00'::timestamp without time zone)แงแแแแแแ แแแแจแแแแแแแแแ แชแแแแแแแ
- WORK_MEM แแฆแฃแแแแก แแแฎแกแแแ แแแแก แแ แแชแแกแก แแ แแ แ แแฎแแแแ แแแแฎแแแแแก: work_mem แแ แแชแแกแแแ แแแแจแแ แแแ = แแแแ แ แแแฎแกแแแ แแแ.
- โ แ แแแแแ แแฃแจแ แแ แแชแแกแก แแแแแแงแแแแแก แจแแแกแ แฃแแแแแแ แแ แแแ แแแ แแแแแแแแ แแแ แแแแแฃแ แ แแแแฃแจแแแแแแกแแแแก.
- โ แแ แแแฃแแแ แแแก แแฃแจแ แแ แแชแแกแแแแก แแแแแแ แ แแแแแแแแแก แกแแ แแแ แแ CPU แแแ แแแแแแก แ แแแแแแแแแแ.
- - แแแแแ, แแแแ แแ แแแ แแแแแฃแ แ แกแแแฃแจแแ แแ แแชแแกแแแแกแแแแก.
แจแแแแแแแ
9.6 แแแ แกแแแก แแแฎแแแแแ, แแแ แแแแแฃแ แแ แแแแฃแจแแแแแแ แจแแแซแแแแ แแแแจแแแแแแแแแ แแแแฃแแฏแแแแกแแก แ แแฃแแ แแแแฎแแแแแแแก แจแแกแ แฃแแแแ, แ แแแแแแแช แกแแแแแ แแแแ แแแแ แกแขแ แแฅแแแก แแ แแแแแฅแกแก. PostgreSQL 10-แจแ แแแ แแแแแฃแ แ แแแแฃแจแแแแแ แฉแแ แแฃแแแ แแแแฃแแแกแฎแแแแแ. แแแฎแกแแแแแ, แ แแ แแแแแ แแแ แแก แกแแ แแแ แแแแ แแแแ OLTP แแแขแแแ แแแแ. แแแแแแแแแแ แฃแแ แกแแแแแ แแแ แแ แแแแแฅแกแแก แกแแแแแ แแแ แแแแฎแแแ แก แฃแแแ แแ แ แแกแฃแ แกแก. แแฃ แแ แแฌแแ แแแแแ แแแแแ แแจแก แแแแ แแแแแชแแแแ แแแแแแ, แจแแแแซแแแแ แแแแฃแแฏแแแแกแแ แจแแแแแฎแแแก แจแแกแ แฃแแแแ แฃแแ แแแแ แแแแแ แแฃแแ แแแแแฅแกแแแแก แแแแแขแแแแ แแ แกแแแแแแแ แแแแแงแแคแแก แแแแแงแแแแแแ.
แแแขแแ แแขแฃแ แ
แฌแงแแ แ: www.habr.com