Zobrazení zdroje stránky PostgreSQL 11 (2018)

<i>Autor: Pavel Stěhule, 2018</i>

Jak už to u každoročních vydání PostgreSQL bývá, k uživatelům se dostává mix několika větších nových vlastností doplněných desítkami menších novinek a vylepšení. Tým vývojářů je stabilní, stabilní je i vývojový proces, který se překvapivě přísně dodržuje. Z těch výraznějších novinek bych především zmínil [https://en.wikipedia.org/wiki/LLVM JIT] pro výrazy, a příkaz <code>CALL</code>, a s tím spojené procedury s možností explicitně řídit transakce. Integrace JIT (ve výchozí konfiguraci vypnuté) je pro mne překvapením - v databázovém světě se jedná o hodně progresivní krok (o to větším překvapením je to v PostgreSQL, kde jsou vývojáři hodně konzervativní) a bezpochyby je PostgreSQL první open source SQL databází, která tuto technologii integruje. Pro uživatele budou zajímavé i další nové funkce - ať už ve využití více CPU pro jeden příkaz - paralel index scan, paralel hash join, postupné vylepšování partitioningu - defaultní partitions, hash partitioning, partition join, podpora přesunu záznamu mezi partitions při <code>UPDATE</code> atd. 

Poznámka autora - pro zajímavost a pro názornost budu uvádět i odkazy na jednotlivé patche. Běžný čtenář se jim určitě věnovat nemusí. Pro někoho může být zajímavý styl a způsob kódování PostgreSQL.
==psql==
Nikdy jsem moc nechápal uživatele, kteří měli problém s ukončením <code>psql</code>. Obvyklé <code>^d</code> na Linuxu funguje 100% (a windows jsem nikdy neřešil). Když si ale vzpomenu na svoje začátky, kdy jsem téměř vždy killoval <code>vi</code>, tak uznávám, že každý musel někdy začít a začátky nebývají lehké. Od nové verze bude <code>psql</code> reagovat i na slova <code>quit</code> a <code>exit</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=df9f599bc6f14307252ac75ea1dc997310da5ba6 p]</small></sup>. Tato slova zafungují, pouze pokud jsou na začátku řádku jednořádkového příkazu.

Od minulé verze je možné v [https://www.postgresql.org/docs/11/static/app-psql.html <code>psql</code>] podmínit zpracování příkazů příkazem <code>\if \elif \else \endif</code>. Jelikož se <code>psql</code> běžně používá pro deployment v prostředích s různými verzemi PostgreSQL, je praktické nějak jednoduše odlišit provádění kódu podle verze PostgreSQL. K tomu by měla posloužit sada nových psql proměnných: <code>SERVER_VERSION_NAME</code>, <code>SERVER_VERSION_NUM</code>, <code>VERSION</code> a <code>VERSION_NAME</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=9ae9d8c1549c384dbdb8363e1d932b7311d25c56 p]</small></sup>. K dokonalosti chybí možnost vyhodnotit základní výrazy pouze v <code>psql</code> (bez komunikace se serverem). Pro lokální vyhodnocení výrazu lze výraz zapsat mezi obrácené apostrofy. Pak se výraz vyhodnotí lokálně shellem:
<pre>
\set myvar 20
\if `[ :myvar -le 10 ] && { echo yes; } || echo no;`
\echo "mensi rovno"
\else
\echo "vetsi"
\endif
</pre>

To ovšem nemusí (a aktuálně nemůže) fungovat na windows. Samozřejmě, že jakýkoliv validní výraz lze vyhodnotit na straně serveru příkazem <code>\gset</code>:
<pre>
SELECT :SERVER_VERSION_NUM >= 11000 AS ver_min_11 \gset
\if :ver_min_11
\echo "Server je 11 nebo novejsi"
\else
\echo "Server je starsi nez verze 11"
\endif
</pre>

V nové verzi už je možné detekovat existenci klientské proměnné zápisem <code>:{?nazev}</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=d57c7a7c506276597af619bdb8c62fa5b592745a p]</small></sup>. Nově také můžeme používat proměnné zobrazující status předchozího SQL příkazu: <code>ERROR</code>, <code>LAST_ERROR_MESSAGE</code>, <code>LAST_ERROR_STATE</code> or <code>SQLSTATE</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=69835bc8988812c960f4ed5aeee86b62ac73602a p]</small></sup>.

V <code>psql</code> nikdy silný skriptovací jazyk nebude. Cokoliv složitějšího vždy bude nutné napsat v Perlu, Pythonu, ... . Je ale snahou, aby se v <code>psql</code> daly jednoduše řešit úlohy obvyklé při testování nebo nasazování.

Příkaz <code>\gdesc</code>] zobrazí popis výsledku dotazu (bez jeho provedení)<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=49ca462eb165dea297f1f110e8eac064308e9d51 p]</small></up>:
<pre>
postgres=# SELECT oid, relname, relkind FROM pg_class \gdesc
┌─────────┬────────┐
│ Column  │  Type  │
╞═════════╪════════╡
│ oid     │ oid    │
│ relname │ name   │
│ relkind │ "char" │
└─────────┴────────┘
(3 rows)

-- může být zajímavé pro výrazy
postgres=# SELECT 10 + 20, 10 + 20.1 \gdesc
┌──────────┬─────────┐
│  Column  │  Type   │
╞══════════╪═════════╡
│ ?column? │ integer │
│ ?column? │ numeric │
└──────────┴─────────┘
(2 rows)
</pre>
==Prostředí uložených procedur==
===Procedury - příkaz <code>CREATE PROCEDURE</code>===

Ve většina databází, kde byly implementovány tzv uložené procedury, se rozlišuje mezi funkcemi a procedurami. Rozdíl není pouze v zápisu. Typicky, ne nutně, se funkce používají v příkazu <code>SELECT</code>, a nelze v nich modifikovat obsah databáze. Procedury jsou aktivované příkazem <code>CALL</code>, nelze je používat v SELECTech, a kód v nich může modifikovat databázi, případně explicitně řídit transakce. Implementace uložených procedur v PostgreSQL je tou výjimkou potvrzující pravidlo. Až do verze 11, programátoři v Postgresu mohli použít pouze funkce (ovšem bez většiny omezení funkcí v ostatních db). Pokud byl kód psán přímo pro Postgres, tak odlišný model (pouze funkce versus procedury a funkce) nepůsobil žádné problémy. Když se kód portoval z jiných databází, tak už s tím občas problémy byly, a občas se část kódu musela přestěhovat do aplikace. Počínaje verzí 11 bude možné i v PostgreSQL psát procedury<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=e4128ee767df3c8c715eb08f8977647ae49dfb59 p]</small></sup> a v těchto procedurách explicitně volat příkazy <code>COMMIT</code> a <code>ROLLBACK</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=8561e4840c81f7e345be2df170839846814fa004 p]</small></sup> (s několika omezeními - např. transakce je možné kontrolovat, pouze pokud prováděný kód byl aktivován pouze příkazem <code>CALL</code>). Procedury mohou mít <code>IN</code> a <code>INOUT</code> parametry<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=33803f67f1c4cb88733cce61207bbf2bd5b599cc p]</small></sup>. Koncepčně je návrh procedur v Postgresu podobný Oracle případně DB2. 

<pre>
CREATE OR REPLACE PROCEDURE foo(a int, INOUT b int, INOUT c int)
AS $$
BEGIN
  b := 10 * a;
  c := 10 + a;
END 
$$ LANGUAGE plpgsql;

-- neinteraktivní volání
postgres=# DO $$
DECLARE b int; c int;
BEGIN
  CALL foo(12, b, c);
  RAISE NOTICE 'b: %, c: %', b, c;
END;
$$;
NOTICE:  b: 120, c: 22
DO

-- interaktivní volání
postgres=# CALL foo(13, NULL, NULL);
┌─────┬────┐
│  b  │ c  │
╞═════╪════╡
│ 130 │ 23 │
└─────┴────┘
(1 row)
</pre>

===Optimalizace práce s kompozitními typy v PL/pgSQL===
Po klidných letech jsme se v [https://www.postgresql.org/docs/11/static/plpgsql.html PL/pgSQL] dočkali výraznější revize kódu pro práci s kompozitními proměnnými. Do verze 11 v PL/pgSQL existovaly statické kompozitní proměnné (tzv ROW type) a dynamické kompozitní proměnné (tzv RECORD type). Důvod pro toto dělení byl historický - ROW typy byly implementovány jako první, a v Postgresu zůstávaly kvůli větší rychlosti práce s proměnnými tohoto typu. Většina ROW types vychází z tabulkek. Jejich metadata se uloží do cache při prvním spuštění funkce. Bohužel při změně tabulky se tato část cache neaktualizuje a nekonzistence cache může způsobit pád funkce v PL/pgSQL. To byl hlavní důvod proč se po změnách struktur tabulek doporučovalo zavřít všechny spojení do Postgresu. Od verze 11 se staré ROW typy nepoužívají. Poměrně velkým refaktoringem se pořešily výkonnostní problémy RECORD typů a tudíž není důvod proč používat ROW type proměnné<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=4b93f57999a2ca9b9c9e573ea32ab1aeaa8bf496 p]</small></sup>. Měly by se tím redukovat poinstalační provozní problémy navázané na změny struktury tabulek.

Díky nové implementaci kompozitních typů bylo možné jednoduše přidat možnost jednoduše definovat výchozí hodnoty i pro kompozitní proměnné (dále je možné nastavit zda-li má být proměnná konstantní, případně <code>NOT NULL</code>)<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=f9263006d871d127794a402a7bef713fdd882156 p]</small></sup>.

==Partitioning==
Oblastí, kde je v PostgreSQL 11 nejviditelnější pokrok, je [https://cs.wikipedia.org/wiki/Partition_(datab%C3%A1ze) <i>partitioning</i>]. Ve verzi 11 se navazuje na nový partitioning z verze 10 a přidávají se nové funkce nebo odstraňují některé limity. Měl by se zrychlit <code>INSERT</code> do partition, a také se změnil algoritmus (<i>partition pruning</i>) pro identifikaci partitions se kterými se bude v SQL příkazu pracovat<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=9fdb675fc5d2de825414e05939727de8b120ae81 p]</small></sup>.

Pro mne asi nejzajímavější vlastností je možnost definovat defaultní partition<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=6f6b99d1335be8ea1b74581fc489a97b109dd08a p]</small></sup> a automatický přesun záznamu mezi partitions<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=2f178441044be430f6b4d626e4dae68a9a6f6cec p]</small></sup>. Defaultní partition se použije, pokud neexistuje odpovídající cílová partition:
<pre>
CREATE TABLE data(a text, vlozeno date) PARTITION BY RANGE(vlozeno);
CREATE TABLE data_2016 PARTITION OF data FOR VALUES FROM ('2016-01-01') TO ('2016-12-31');
CREATE TABLE data_2017 PARTITION OF data FOR VALUES FROM ('2017-01-01') TO ('2017-12-31');
CREATE TABLE data_other PARTITION OF DATA DEFAULT;

postgres=# INSERT INTO data VALUES('hello', '2015-06-08');
INSERT 0 1
postgres=# SELECT * FROM data_other ;
┌───────┬────────────┐
│   a   │  vlozeno   │
╞═══════╪════════════╡
│ hello │ 2015-06-08 │
└───────┴────────────┘
(1 row)

postgres=# UPDATE data SET a = 'Hi' WHERE vlozeno = '2015-06-08';
UPDATE 1
postgres=# SELECT * FROM data_other ;
┌────┬────────────┐
│ a  │  vlozeno   │
╞════╪════════════╡
│ Hi │ 2015-06-08 │
└────┴────────────┘
(1 row)

postgres=# UPDATE data SET a = 'Nazdar', vlozeno = '2017-08-23' WHERE vlozeno = '2015-06-08';
UPDATE 1
postgres=# SELECT * FROM data_other ;
┌───┬─────────┐
│ a │ vlozeno │
╞═══╪═════════╡
└───┴─────────┘
(0 rows)

postgres=# SELECT * FROM data_2017;
┌────────┬────────────┐
│   a    │  vlozeno   │
╞════════╪════════════╡
│ Nazdar │ 2017-08-23 │
└────────┴────────────┘
(1 row)
</pre>

V <code>psql</code> bylo vylepšeno zobrazení struktury partitiovaných tabulek<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=05b6ec39d72f7065bb5ce770319e826f1da92441 p]</small></sup>:
<pre>
postgres=# \d data
                Table "public.data"
┌─────────┬──────┬───────────┬──────────┬─────────┐
│ Column  │ Type │ Collation │ Nullable │ Default │
╞═════════╪══════╪═══════════╪══════════╪═════════╡
│ a       │ text │           │          │         │
│ vlozeno │ date │           │          │         │
└─────────┴──────┴───────────┴──────────┴─────────┘
Partition key: RANGE (vlozeno)
Number of partitions: 3 (Use \d+ to list them.)

postgres=# \d+ data
                                    Table "public.data"
┌─────────┬──────┬───────────┬──────────┬─────────┬──────────┬──────────────┬─────────────┐
│ Column  │ Type │ Collation │ Nullable │ Default │ Storage  │ Stats target │ Description │
╞═════════╪══════╪═══════════╪══════════╪═════════╪══════════╪══════════════╪═════════════╡
│ a       │ text │           │          │         │ extended │              │             │
│ vlozeno │ date │           │          │         │ plain    │              │             │
└─────────┴──────┴───────────┴──────────┴─────────┴──────────┴──────────────┴─────────────┘
Partition key: RANGE (vlozeno)
Partitions: data_2016 FOR VALUES FROM ('2016-01-01') TO ('2016-12-31'),
            data_2017 FOR VALUES FROM ('2017-01-01') TO ('2017-12-31'),
            data_other DEFAULT
</pre>
S vyjímkou přesunu záznamu do jiné partition je podporovaný i merge - v PostgreSQL příkaz <code>INSERT ON CONFLICT</code>. Vždy by měla být funkční varianta <code>INSERT ON CONFLICT DO NOTHING</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=87c37e3291cb75273ccdf4645b9472dd805c4493 p]</small></sup>. Příkaz <code>INSERT ON CONFLICT DO UPDATE</code> by měl fungovat se zmíněným omezením<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=555ee77a9668e3f1b03307055b5027e13bf1a715 p]</small></sup>.

Novinkou je základní podpora hash partitioningu<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=1aba8e651ac3e37e1d2d875842de1e0ed22a651e p]</small></sup>:
<pre>
CREATE TABLE pht1 (a int, b int, c text) PARTITION BY HASH(c);
CREATE TABLE pht1_p1 PARTITION OF pht1 FOR VALUES WITH (MODULUS 3, REMAINDER 0);
CREATE TABLE pht1_p2 PARTITION OF pht1 FOR VALUES WITH (MODULUS 3, REMAINDER 1);
CREATE TABLE pht1_p3 PARTITION OF pht1 FOR VALUES WITH (MODULUS 3, REMAINDER 2);
</pre>

Pokud se shoduje partitioning dvou joinovaných tabulek, pak lze použít tzv <i>partition-wise join</i><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=f49842d1ee31b976c681322f76025d7732e860f3 p]</small></sup>. Join na úrovni partition je úspornější. Na druhou stranu, detekce jestli je možné tento typ joinu použít, je výpočetně náročná úloha, a proto je defaultně vypnutá. Lze ji zapnout volbou <code>enable_partition_wise_join = on</code>. Podobný trik lze použít i pro agregaci, pokud agregujeme alespoň podle jednoho klíče použitého pro řízení partitioningu<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=e2f1eb0ee30d144628ab523432320f174a2c8966 p]</small></sup>. Tím, že se agregace provede na úrovni partitions (a nikoliv tabulky) jakoby zmenšíme velikost vstupních dat, a tudíž je možné, že se lépe vejdeme do operační paměti a použije se rychlejší (paměťově náročnější) algoritmus. Také tato optimalizace je kvůli náročnosti na plánování defaultně vypnutá a pro její aktivaci je nutné ji zapnout konfigurací <code>enable_partitionwise_aggregate = on</code>.

Nově také můžeme psát <code>FOR EACH ROW</code> after triggery i pro partitiované tabulky<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=86f575948c773b0ec5b0f27066e37dd93a7f0a96 p]</small></sup>.

Od PostgreSQL 11 můžeme vytvářet indexy nad partitiovanými tabulkami<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=8b08f7d4820fd7a8ef6152a9dd8c6e3cb01e5f99 p]</small></sup>. S vytvořením indexu na partitiované tabulce se index automaticky vytvoří i na všech partitions (v Postgresu, rekurzivně na všech tabulkách, které se používají jako partition). Partitiované tabulky mohou obsahovat i unikátní index<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=eb7ed3f3063401496e4aa4bd68fa33f0be31a72f p]</small></sup>, případně na těchto tabulkách může být definovaný primární klíč. Platí ovšem podmínka, že unikátní index případně primární klíč musí obsahovat atribut(y), který(é) řídí partitioning:
<pre>
CREATE UNIQUE INDEX ON data(a, vlozeno);
ALTER TABLE data ADD PRIMARY KEY (a, vlozeno);
</pre>

Zatím nelze vytvořit cizí klíče vůči partitiované tabulce, nicméně alespoň již můžeme v partitiované tabulce používat cizí klíče<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=3de241dba86f3dd000434f70aebba725fb928032 p]</small></sup>.

Ve starších verzích detekce použitých partitions proběhla pouze v čase plánování dotazu. Pokud při plánování dotazu nebyly k dispozici potřebné informace, tak planner použil všechny partitions. Od nové verze Postgres dokáže eliminovat partitions i v době zpracování dotazu <sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=499be013de65242235ebdde06adb08db887f0ea5 p]</small></sup>. Měly by být podporované operace <i>append</i>, <i>nested loop</i> a <i>init plans</i> (První poznámka: ještě to trochu kulhá, implementace si neporadí s funkcemi a pseudo konstantami (<code>CURRENT_DATE</code>, <code>CURRENT_TIMESTAMP</code>. Druhá poznámka: existuje patch, který tuto situaci opravuje. Není ale zřejmé, jestli bude aplikován v jedenáctce nebo až v další verzi.).

==Administrace==
Již v předchozích verzích byl příkaz <code>ALTER TABLE ADD COLUMN</code> extrémně rychlý, a to díky tomu, že došlo pouze ke změně metadat. Na data se vůbec nesahalo. Počínaje verzí 11 to platí i pro příkaz <code>ALTER TABLE ADD COLUMN DEFAULt expr</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=16828d5c0273b4fe5f10f42588005f16b415b2d8 p]</small></sup>.

Nový příkaz [https://www.postgresql.org/docs/11/static/pgverifychecksums.html <code>pg_verify_checksums</code>] slouží k offline ověření kontrolních součtů datových stránek.
 
Nově si [https://www.postgresql.org/docs/11/static/pgprewarm.html <code>pg_prewarm</code>] díky svému Background Work procesu periodicky ukládá stav shared buffers (cache datových stránek v PostgreSQL). Po restartu serveru druhým BG procesem na základě uloženého stavu obnoví obsah cache<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=79ccd7cbd5ca44bee0191d12e9e65abf702899e7 p]</small></sup>.

Přepínačem <code>--create-slot</code> příkazu <code>pg_basebackup</code> lze vynutit vytvoření trvalého replikačního slotu, jehož název je určen přepínačem <code>--slot</code>. 

Novým parametrem tabulky <code>toast_tuple_target</code> v rozmezí 128 bajtů a 8KB můžeme určit velikost hodnot, které se budou ukládat externě - v tzv TOAST tabulkách (výchozí hodnota odpovídá 2KB).

==Optimalizace výkonu==
===Použití více CPU pro příkaz===
[https://www.enterprisedb.com/blog/parallel-hash-postgresql Velké úsilí] stála implementace paralelního hash joinu<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=1804284042e659e7d16904e7bbb0ad546394b6a3 p]</small></sup>. Pro uživatele s většími databázemi, a náročnějšími dotazy by zrychlení provádění dotazů mělo být výrazné. V nové verzi PostgreSQL může použít více CPU i pro dotazy obsahující poddotazy (což v předchozích verzích zpracování přes více CPU blokovalo)<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=e89a71fb449af2ef74f47be1175f99956cf21524 p]</small></sup>. Paralelní zpracování dotazů je nyní možné i pro dotazy příkazem <code>CREATE TABLE AS SELECT</code>. Zparalelizována byla i klauzule <code>UNION ALL</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=0927d2f46ddd4cf7d6bf2cc84b3be923e0aedc52 p]</small></sup>:

<pre>
SET LOCAL parallel_setup_cost = 10;
EXPLAIN (COSTS OFF)
SELECT unique1 FROM tenk1 WHERE fivethous = tenthous + 1
UNION ALL
SELECT unique1 FROM tenk1 WHERE fivethous = tenthous + 1;
                     QUERY PLAN                     
----------------------------------------------------
 Gather
   Workers Planned: 4
   ->  Parallel Append
         ->  Parallel Seq Scan on tenk1
               Filter: (fivethous = (tenthous + 1))
         ->  Parallel Seq Scan on tenk1 tenk1_1
               Filter: (fivethous = (tenthous + 1))
(7 rows)
</pre>

Paralelizovat lze i řazení<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=9da0cc35284bdbe8d442d732963303ff0e0a40bc p]</small></sup>. Zrychlení by mělo být vidět při vytváření indexů <code>CREATE INDEX</code>.

===Statistiky, odhady, a optimalizace prováděcích plánů===
Nově se při kalkulaci odhadů rozlišuje] mezi operátorem <code>&lt;</code> a operátorem <code>&lt;=</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=7d08ce286cd5854d58152e428c28636a616bdc42 p]</small></sup>. Ve starších verzích se  <code>&lt;=</code> převádělo na <code>&lt;</code>. Totéž platí a platilo pro <code>&gt;</code> a <code>&gt;=</code>. Existovaly situace, kdy starší zjednodušená implementace dávala špatné odhady, např. když hodnoty <code>a</code> a <code>b</code> ve výrazu <code>x BETWEEN a AND b</code> byly blízko sebe.

V PostgreSQL se ke každému sloupci udržuje seznam nejčastějších hodnot (<i>Most Common Values</i>) včetně pravděpodobnosti výskytu těchto hodnot. Do verze 11 se do tohoto seznamu ukládaly hodnoty jejichž pravděpodobnost výskytu bylo o 25% vyšší než pravděpodobnost výskytu všech not null hodnot. Nově je seznam nejčastějších hodnot definován jako co největší množina hodnot, jejichž pravděpodobnost výskytu je větší než průměrná pravděpodobnost výskytu hodnot nezařazených do seznamu MCV. Nová kalkulace by měla se lépe chovat v případech, kdy několik málo hodnot má větší než průměrnou pravděpodobnost výskytu. Pro rovnoměrné rozdělení by měl být seznam MCV menší a pro nerovnoměrná rozdělení naopak větší<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=b5db1d93d2a6e2d3186f8798a5d06e07b7536a1d p]</small></sup>.

Změnil se i výpočet ceny za bitmap index scan<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=5edc63bda68a77c4d38f0cbeae1c4271f9ef4100 p]</small></sup>. Nová kalkulace je bližší realitě, a měla by prodražit bitmap index scan v situacích, kdy se vytvořená bitmapa nevejde do <code>work_mem</code>, a místo s mapou řádek se pracuje s mapou stránek.

===Práce s indexy===
Příkaz <code>VACUUM</code> vytváří (nastavuje) bitmapu stránek, které neobsahují smazané záznamy (<i>visibility map</i>). Pokud je tato mapa k dispozici, a pokud index obsahuje všechny potřebné sloupce k vykonání dotazu, pak optimalizátor může použít přístupovou metodu (k datům) <i>index only scan</i>. Tím se ušetří náhodné přístupy do tabulky. Od verze jedenáct se stejná optimalizace může použít i pro <i>bitmap scan</i> (sekvenční čtení souboru akcelerované indexem)<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=7c70996ebf0949b142a99c9445061c3c83ce62b3 p]</small></sup>.

Index only scan nelze použít, pokud index neobsahuje všechny potřebné hodnoty použité v dotazu. Od verze 11 je možné index vytvořit včetně tzv neklíčových položek (nepoužijí se pro vyhledávání, ale jsou uložené v indexu)<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=8224de4f42ccf98e08db07b43d52fed72f962ebb p]</small></sup>. Pro indexy obsahující neklíčové položky se také používá název <i>covering indexes</i>:
<pre>
CREATE UNIQUE INDEX ON upsert(lower(key)) INCLUDE (payload);
CREATE TABLE lcku_table (id INTEGER, value TEXT, PRIMARY KEY (id) INCLUDE (value));
</pre>

V případě, že se aktualizuje neoindexovaný sloupec, tak PostgreSQL použije tzv <i>hot-update</i> (Heap Only). Tento způsob aktualizace je výrazně rychlejší, jelikož nevyžaduje aktualizaci indexů nad tabulkou. V nové verzi PostgreSQL použije hot-update i po aktualizaci indexovaného sloupce funkcionálním indexem, pokud nedojde ke změně výsledku zaindexované vypočítané hodnoty<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=c203d6cf81b4d7e43edb2b75ec1b741ba48e04e0 p]</small></sup>. Tato novinka by měla zrychlit aktualizace řádků s XML, případně JSON dokumenty, kde se používá funkcionální index pro přístup k vybraným klíčovým položkám (které jsou často neměnné).

Nový operátor <code>^@</code> je akcelerován SP-GiST indexem a může být použitý jako alternativa pro vyhledávání podle prefixu řetězce<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=710d90da1fd8c1d028215ecaf7402062079e99e9 p]</small></sup>:
<pre>
-- stara klasika, nefunguje pro ^@
CREATE INDEX ON obce(nazev varchar_pattern_ops);
postgres=# EXPLAIN SELECT * FROM obce WHERE nazev like 'Ben%';
┌──────────────────────────────────────────────────────────────────────────────────────┐
│                                      QUERY PLAN                                      │
╞══════════════════════════════════════════════════════════════════════════════════════╡
│ Index Scan using obce_nazev_idx on obce  (cost=0.28..8.30 rows=1 width=41)           │
│   Index Cond: (((nazev)::text ~>=~ 'Ben'::text) AND ((nazev)::text ~<~ 'Beo'::text)) │
│   Filter: ((nazev)::text ~~ 'Ben%'::text)                                            │
└──────────────────────────────────────────────────────────────────────────────────────┘
(3 rows)

-- nova moznost
CREATE INDEX ON obce USING spgist(nazev);

postgres=# EXPLAIN SELECT * FROM obce WHERE nazev like 'Ben%';
┌──────────────────────────────────────────────────────────────────────────────────────┐
│                                      QUERY PLAN                                      │
╞══════════════════════════════════════════════════════════════════════════════════════╡
│ Index Scan using obce_nazev_idx on obce  (cost=0.15..8.17 rows=1 width=41)           │
│   Index Cond: (((nazev)::text ~>=~ 'Ben'::text) AND ((nazev)::text ~<~ 'Beo'::text)) │
│   Filter: ((nazev)::text ~~ 'Ben%'::text)                                            │
└──────────────────────────────────────────────────────────────────────────────────────┘
(3 rows)

-- novy operator
postgres=# EXPLAIN SELECT * FROM obce WHERE nazev ^@ 'Ben';
┌────────────────────────────────────────────────────────────────────────────┐
│                                 QUERY PLAN                                 │
╞════════════════════════════════════════════════════════════════════════════╡
│ Index Scan using obce_nazev_idx on obce  (cost=0.15..8.17 rows=1 width=41) │
│   Index Cond: ((nazev)::text ^@ 'Ben'::text)                               │
└────────────────────────────────────────────────────────────────────────────┘
(2 rows)
</pre>

==Ostatní==
Doménové typy jsou jakési aliasy pro ostatní datové typy. Na základě typu <code>bigint</code> si mohu vytvořit doménový typ pro identifikátory:
<pre>
CREATE DOMAIN id_type AS bigint NOT NULL;
</pre>

Pak kdekoliv mohu používat <code>id_type</code> ve smyslu názvu datového typu. Nově lze vytvářet domény z kompozitních typů<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=37a795a60b4f4b1def11c615525ec5e0e9449e05 p]</small></sup>, a také lze vytvářet pole doménového typu<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=c12d570fa147d0ec273df53de3a2802925d551ba p]</small></sup>. Doménové typy jsou ANSI/SQL alternativou ku referencovaným typům používaným v Oracle.

Nově jsou B-tree indexy optimalizovány pro vkládání zvyšujících se hodnot<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=2b27273435392d1606f0ffc95d73a439a457f08e p]</small></sup>. Pokud byla vložena aktuálně největší hodnota, pak se její pozice a hodnota uloží do cache. V případě, že vkládáme další ještě větší hodnotu, pak se neprohledává strom indexu, ale rovnou se použije pozice z cache. Na desítce je vložení zvyšujících se hodnot o něco málo rychlejší než vkládání náhodných dat. V PostgreSQL 11 je vložení cca 1M zvyšujících se hodnot o &#8531; rychlejší než vložení náhodných hodnot. Jaký bude výsledek v praxi jde těžko odhadnout - většinou je nutné obsluhovat více indexů, a zvyšující se posloupnost je většinou pouze u několika málo sloupců.

Přidáním podpory klauzule <code>RANGE offset PRECEDING/FOLLOWING</code> je v PostgreSQL kompletní podpora window funkcí, tak jak ji definuje ANSI/SQL<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=0a459cec96d3856f476c2db298c6b52f592894e8 p]</small></sup>. Pro většinu uživatelů tato skutečnost bude téměř neviditelná.

Naopak, uživatelé, kteří používají logickou replikaci, a těch je docela hodně, uvítají, že v nové verzi logická replikace podporuje i příkaz <code>TRUNCATE</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=039eb6e92f20499ac36cc74f8a5cef7430b706f6 p]</small></sup>.

Pro uživatele fulltextu v Postgresu bude zajímavá funkce <code>websearch_to_tsquery</code> a možná i funkce <code>phraseto_tsquery</code><sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=1664ae1978bf0f5ee940dc2fc8313e6400a7e7da p]</small></sup>. První umožňuje specifikovat výběr zápisem obvyklým pro webové aplikace - např. <code>"sad cat" or "fat rat"</code>. Tato funkce je také tolerantní k chybám zápisu hledaného výrazu. Druhá funkce vyhledává fráze - slova ve správném pořadí:
<pre>
-- vyžaduje speciální syntax
postgres=# SELECT * FROM obce WHERE to_tsvector(nazev) @@ to_tsquery('mladá boleslav');
ERROR:  syntax error in tsquery: "mladá boleslav"

-- nevyžaduje speciální syntax
postgres=# SELECT * FROM obce WHERE to_tsvector(nazev) @@ websearch_to_tsquery('mladá boleslav');
┌─────┬──────────┬────────────────┬────────────┬───────────┬──────────┬─────────┐
│ id  │ okres_id │     nazev      │ pocet_muzu │ pocet_zen │ vek_muzu │ vek_zen │
╞═════╪══════════╪════════════════╪════════════╪═══════════╪══════════╪═════════╡
│ 613 │ CZ0207   │ Mladá Boleslav │      22462 │     22288 │     38.9 │    42.1 │
└─────┴──────────┴────────────────┴────────────┴───────────┴──────────┴─────────┘
(1 row)

postgres=# SELECT * FROM obce WHERE to_tsvector(nazev) @@ websearch_to_tsquery('mladá boleslav or mladá vožice');
┌──────┬──────────┬────────────────┬────────────┬───────────┬──────────┬─────────┐
│  id  │ okres_id │     nazev      │ pocet_muzu │ pocet_zen │ vek_muzu │ vek_zen │
╞══════╪══════════╪════════════════╪════════════╪═══════════╪══════════╪═════════╡
│  613 │ CZ0207   │ Mladá Boleslav │      22462 │     22288 │     38.9 │    42.1 │
│ 1705 │ CZ0317   │ Mladá Vožice   │       1335 │      1392 │     39.2 │    41.4 │
└──────┴──────────┴────────────────┴────────────┴───────────┴──────────┴─────────┘
(2 rows)

postgres=# SELECT * FROM obce WHERE to_tsvector(nazev) @@ websearch_to_tsquery('mladá boleslav or vožice');
┌──────┬──────────┬─────────────────────────┬────────────┬───────────┬──────────┬─────────┐
│  id  │ okres_id │          nazev          │ pocet_muzu │ pocet_zen │ vek_muzu │ vek_zen │
╞══════╪══════════╪═════════════════════════╪════════════╪═══════════╪══════════╪═════════╡
│  613 │ CZ0207   │ Mladá Boleslav          │      22462 │     22288 │     38.9 │    42.1 │
│ 1705 │ CZ0317   │ Mladá Vožice            │       1335 │      1392 │     39.2 │    41.4 │
│ 1712 │ CZ0317   │ Nová Ves u Mladé Vožice │         91 │        86 │     40.9 │    43.8 │
│ 1764 │ CZ0317   │ Zhoř u Mladé Vožice     │         44 │        51 │     40.1 │    38.2 │
└──────┴──────────┴─────────────────────────┴────────────┴───────────┴──────────┴─────────┘
(4 rows)
</pre>

Zajímavě vypadá funkce <code>strict_word_similarity</code>, která se podobá funkci <code>word_similarity</code>, ale na rozdíl od ní bere v potaz hranice slov<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=be8a7a6866276b228b4ffaa3003e1dc2dd1d140a p]</small></sup>.

FDW API umožňovalo úpravy dat cizích tabulek, jelikož se ale jelo po jednom záznamu nad primárním klíčem, tak tyto operace byly relativně náročné. Počínaje novou verzí je možné distribuovat příkazy <code>UPDATE</code>, <code>DELETE</code> na cizí server, a který je může provést efektivně jako hromadnou operaci<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=1bc0100d270e5bcc980a0629b8726a32a497e788 p]</small></sup>.

I v minulých verzích bylo možné napsat extenze, které provedly určitou činnost při přihlášení a odhlášení do databáze. Jelikož zachycení těchto událostí nebylo explicitně podporováno, tak tyto extenze byly postavené tak trochu na vodě. V PostgreSQL 11 je možné využít hooky <code>session_start_hook</code> a <code>session_end_hook</code>, a extenzi s tímto chováním napsat čistě a jednoduše<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=cd8ce3a22c0b48d32ffe6543837ba3bb647ac2b2 p]</small></sup>.

Ve verzi 11 je lze příkazem <code>LOCK</code> explicitně zamknout pohled podobně jako tabulku<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=34c20de4d0b0ea8f96d0c518724d876c7b984cf5 p]</small></sup>. Zamknutí pohledu vedek k rekurzivnímu zamknutí tabulek použitých v pohledu.

Pokračuje se v trendu separovat práva superuživatele a umožnit některá jeho práva nastavit běžnému uživateli. Role <code>pg_read_server_files</code>, <code>pg_write_server_files</code> a <code>pg_execute_server_program</code> umožní uživateli použít funkce pro čtení souborů serveru, případně pro zápis do souboru nebo spuštění programu ze serveru - příkazy <code>COPY</code> a <code>COPY TO/FROM PROGRAM</code> na straně serveru<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=0fdc8495bff02684142a44ab3bc5b18a8ca1863a p]</small></sup>.

<code>pgbench</code> je aplikace pro většinu uživatelů PostgreSQL absolutně nezajímavá. Každým rokem ovšem sdílí více a více kódu s SQL konzolí <code>psql</code>. A proto může být zajímavé, že od nové verze je k dispozici relativně široká nabídka matematických a logických operátorů<sup><small>[https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=bc7fa0c15c590ddf4872e426abd76c2634f22aca p]</small></sup>, které jak doufám, se dostanou i do <code>psql</code>:
<pre>
\set c0 debug(1.0 = 0.0 and 1.0 != 0.0)
\set c1 debug(0 = 1 Or 1.0 = 1)
\set c4 debug(case when 0 < 1 then 32 else 0 end)
</pre>

==TimescaleDB & PipelineDB==
Nad kódem PostgreSQL vznikla řada dalších databází optimalizovaných, rozšířených pro specifické úlohy. BSD licence, se kterou je licencován kód PostgreSQL, ničemu takovému nebrání, a stejně tak se těmto forkům (většinou komerčním) nebrání komunita. Je to způsob, jak se další a další vývojáři mohou seznámit s kódem Postgresu, a případně začít psát i pro upstream. Navíc složitější kód se nevyplácí držet mimo upstream - pozdější synchronizace je nepříjemná a náročná práce. Aktuálně asi nejpopulárnější forky PostgreSQL jsou [https://www.enterprisedb.com/ EnterpriseDB] (cílí na uživatele Oracle) a [https://www.citusdata.com/ Citus] (OLAP a MPP). Staršími forky jsou např. databáze [https://www.ibm.com/analytics/netezza Netezza], [https://greenplum.org/ Pivotal Greenplum database] nebo [https://en.wikipedia.org/wiki/Amazon_Redshift Amazon Redshift].

Pokud se jedná o více změn, tak pak údržba nebo vývoj vlastního forku PostgreSQL není levná záležitost (není problém mít několik i možná desítek kratších patchů). Starší forky jsou úplně odtržené od Postgresu a mnohokrát z hlediska SQL, případně uživatelského komfortu jsou zastaralé. Greenplum už cca 2 roky migruje z PostgreSQL 8.2, a aktuálně jsou na 9.0. V CitusData byli první, kdo svůj fork přepsali do formátu extenze PostgreSQL. Extenze v PostgreSQL mají svůj kód izolovaný od kódu PostgreSQL a tudíž údržba extenze je výrazně jednodušší a méně pracná než údržba forku. Další databází, která byla původně forkem a nyní se [https://www.pipelinedb.com/blog/pipelinedb-0-9-9-one-more-release-until-pipelinedb-is-a-postgresql-extension transformovala do extenze] je PipelineBD. Stejně tak, jak je údržba extenze jednodušší než údržba forku, tak je používání extenze jednodušší než používání forku.

===TimescaleDB===
[https://www.timescale.com/ <i>TimescaleDB</i>] je relativně nová komerční (s otevřeným kódem) extenze, která do PostgreSQL přidává některé vlastnosti tzv <i>timeseries</i> databází. Rozšiřuje partitioning v PostgreSQL o automaticky vytvářené partitions (definované časovým obdobím). Kromě jedné povinné dimenze pro partitioning (časové období) lze vytvářet partitions ještě podle jednoho vybraného atributu. Ve výsledku můžeme dostat 2D partitioning (např. podle času a kódu země). Jelikož je partitioning v TimescaleDB předepsán hodně natvrdo, tak může být a je lépe optimalizován než obecný partitioning v Postgresu (ten má problémy s větším počtem patitions (cca 100 je ještě ok)). 

Kromě toho umí v dotazu identifikovat některé vybrané funkce (např. <code>date_trunc</code>) a lépe optimalizovat dotazy, které tyto funkce používají. Pro Postgres jsou téměř všechny funkce black box, a tudíž optimalizátor nemůže být příliš agresivní (navíc ani správně nedokáže odhadnout výsledek). 

S touto extenzí Postgres automaticky vytváří množství menších partitions. Jelikož se indexy nad menšími tabulkami dobře vejdou do RAM, tak je aktualizace indexu rychlou operací a tudíž se TimescaleDB může pochlubit relativně stabilní rychlostí vkládání dat do db. Některé časté dotazy z oblasti timeseries databází jsou pak díky rozpoznání chování funkce a následné optimalizaci znatelně rychlejší. Na některých úlohách může být vidět, že TimescaleDB je hybridní databáze a nativní [https://en.wikipedia.org/wiki/Time_series_database timeseries databáze] budou výrazně rychlejší. Nicméně v mnoha případech díky TimescaleDB bude výkon Postgresu pro danou úlohu dostačující a naopak díky Postgresu uživatel získá komfort v podobě silného SQL (a v případě, že již zná Postgres, tak si nemusí svůj stack rozšiřovat o další technologii).

===PipelineDB===
Existence proudových databází (<i>stream databases</i>) je drtivé většině uživatelů dobře utajena, ačkoliv by se řadě uživatelů perfektně hodily. O těchto databázích se hodně mluvilo na přelomu milénia, bohužel bez větší odezvy uživatelů. Dnes se k těmto databázím dostáváme oklikou přes architektury založené na zpracování proudů dat (např. Apache Kafka). [https://www.pipelinedb.com/ PipelineDB] je pokus přiblížit tyto databáze uživatelům - do klasického Postgresu zavádí nové objekty a operace: <i>stream buffer</i>, <i>continuous aggregation</i>, <i>sliding window queries</i>, atd.

<pre>
CREATE STREAM wiki_stream (hour timestamp, project text, title text, view_count bigint, size bigint);
CREATE CONTINUOUS VIEW wiki_stats AS
SELECT hour, project,
        count(*) AS total_pages,
        sum(view_count) AS total_views,
        min(view_count) AS min_views,
        max(view_count) AS max_views,
        avg(view_count) AS avg_views,
        percentile_cont(0.99) WITHIN GROUP (ORDER BY view_count) AS p99_views,
        sum(size) AS total_bytes_served
FROM wiki_stream
GROUP BY hour, project;"
</pre>

Kontinuální pohled, jestli je to možné tak přeložit, je jakási obdoba neustále aktualizovaného materializovaného pohledu. <code>INSERT</code> do proudu <code>wiki_stream</code> způsobí chytrou aktualizaci pohledu. Neprovádí se klasická agregace, ale pouze aktualizace čítačů. Díky tomu bez větších nároků na CPU a IO můžeme mít k dispozici on-line agregovaná data. 

Letošní rok je pro PipelineDB přelomový. Z forku Postgresu se [https://www.pipelinedb.com/blog/pipelinedb-0-9-8-postgresql-extension-refactor-nearing-completion mění na extenzi] Postgresu. Po způsobu Citusu a TimescaleDB. Bohužel v extenzích PostgreSQL není možné rozšiřovat SQL - zatím nikdo nepřišel jak dynamicky rozšiřovat parser generovaný [https://www.gnu.org/software/bison/ bisonem]. Tudíž PipelineDB přijde o svá rozšíření SQL (která podle mne zjednodušují a zpřehledňují zápis), na oplátku se zbaví nutnosti udržovat své vlastní buildy PostgreSQL. Údržba extenze je výrazně omezenější, jednoduší. Naštěstí jazyk a prostředky v PostgreSQL jsou dostatečně silné, takže požadovanou funkcionalitu je možné implementovat:
<pre>
-- původní zápis
CREATE STREAM <stream>
-- nový zápis
CREATE FOREIGN TABLE s (x integer, ...) SERVER pipelinedb;

-- původní zápis
CREATE CONTINUOUS VIEW continuous_view AS SELECT count(*) FROM s;
-- nový zápis
CREATE VIEW continuous_view WITH (action=materialize, ...) AS SELECT count(*) FROM s;
</pre>

Mám rád bohaté barokní SQL. Líbí se mi stará syntaxe, která je názorná, nekomplikovaná. Naprosto ale rozumím důvodům, proč PipelineDB přechází na jiný formát. Extenzi je nepoměrně jednodušší udržovat i doručovat uživatelům, případně budoucím zákazníkům. Nicméně, kdyby někdo dokázal dynamicky rozšiřovat parser generovaný z gramatiky bisonu, tak ať se mi ozve. Rád mu zaplatím pivko.

==Závěr==
PostgreSQL má za sebou dobré roky, kdy se začíná postupně a úspěšně nasazovat i v korporátním prostředí, ve kterém se o open source databáze ještě před několika lety nezavadilo, a stávající uživatelé jsou vesměs spokojeni. Veškerá energie, co jde do vývoje a práce vývojářů je vidět.

Co můžeme čekat od verze 12? Pravděpodobně podporu JSONu podle ANSI/SQL, nové techniky optimalizace dotazu (přepis podmínek <code>OR</code> na <code>UNION</code>, natlačení agregace před JOIN, nové typy úložišť (např. [https://github.com/EnterpriseDB/zheap <i>zheap</i>], které není nutné vacuuovat), možná session proměnné, skoro určitě <code>MERGE</code> podle ANSI/SQL, možná transparentní šifrování. Plánů, prototypů i téměř hotových patchů je hodně. Uvidíme, co bude příští rok. 
----------
<DPL>category=Verze PostgreSQL</DPL>
[[Category:Články]]
[[Category:Verze PostgreSQL]]