Vlastní funkce v PostgreSQL

Funkce dělá přesně to, co její matematický protějšek. Pro vstupní hodnotu vrátí určitý údaj. My si nyní vytvoříme funkci, co nebude vyžadovat argument a vždy vrátí číslo jedna — to jen pro zahřátí, taková funkce samozřejmě není moc užitečná, ale alespoň se podíváme, jak vlastně vypadá její syntaxe.

CREATE FUNCTION test() RETURNS integer AS $$

SELECT 1 AS result;

$$ LANGUAGE SQL;

SELECT test(); --vypíše 1

Nejprve s pomocí CREATE FUNCTION vymezíme, že začínáme psát funkci. Poté uvedeme její název (zde test) a prázdnou závorku, protože nepřebíráme žádné argumenty. Databázový server zajímá, jaký datový typ bude naše funkce vracet, proto jej uvedeme (integer). Za klíčovým slovem AS začíná vymezení samotného těla funkce, které z obou strany obklopuje symbol dvou dolarů ($$). Závěrem uvedeme použitý jazyk (LANGUAGE SQL) a nezapomeneme na středník, podobně jako v těle funkce, ve kterém jednoduše s pomocí příkazu SELECT získáme číselnou hodnotu 1.

Pojďme zkusit něco užitečnějšího, naučíme se používat argumenty:

CREATE FUNCTION plus(integer, integer) RETURNS integer AS $$
 SELECT $1 + $2 AS result;
$$ LANGUAGE SQL;

SELECT plus(10, 5); --vypíše 15

SELECT plus(5, 'a'); --Error in query: ERROR: invalid input syntax for integer: "a"

Tato funkce umí sečíst dvě čísla. U argumentů uvádíme jen datový typ a na hodnotu se odkazujeme s pomocí dolaru a indexu (první argument je dostupný s pomocí $1).

Než se vhrneme na náš první trigger, smažeme z databáze vytvořené funkce. Udělá se to následovně:

DROP FUNCTION test();

DROP FUNCTION plus(integer, integer);

Jednoduchý trigger v PostgreSQL

Na úvod si představme, že máme tabulku human  obsahující údaje o lidech. Uchováváme jedinečné ID, jméno, příjmení a oslovení. Napíšeme si trigger, který nám bude zmíněné oslovení generovat automaticky. Nejprve vytvoříme samotnou funkci, kterou server následně automaticky zavolá. Daná funkce nebude dělat nic jiného, než že vezme jméno i příjmení a spojí oba údaje mezerou.

CREATE FUNCTION concatenate() returns trigger AS $$
BEGIN
UPDATE human SET salutation = (NEW.name || ' ' || NEW.surname) WHERE id = NEW.id;
RETURN NULL;
END;
$$ LANGUAGE plpgsql;

Oproti zápisu funkce je zde několik rozdílů. Trigger nikdy nemá argumenty a jako návratový typ uvádíme slovo trigger. Do těla se nám dostala část BEGIN a END; (pozor na středník). Uvnitř těla smíme používat proměnnou NEW, která odkazuje na nově vytvořený/upravený řádek. Příkazem RETURN vracíme výsledek funkce (zde je NULL, protože nic vracet nechceme). Klauzule LANGUAGE obsahuje plpgsql, protože píšeme trigger pro PostgreSQL.

Pojďme nyní naší tabulku donutit, ať trigger volá automaticky při každém vložení hodnoty:

CREATE TRIGGER human_trigger AFTER INSERT ON human
FOR EACH ROW EXECUTE PROCEDURE concatenate();

Zápis je hodně upovídaný a osobně se mi špatně pamatuje. Zase se naopak dobře čte :-). Uvádíme pojmenování našeho triggeru (human_trigger), název tabulky (human) a samotnou funkci, co bude volána (concatenate());

A nyní pozor, stačí nám spustit následující příkaz a v tabulce objevíme automaticky vygenerované oslovení:

INSERT INTO human(name, surname, salutation) VALUES ('Jan', 'Novák', '?');

Sloupec salutation nedovoluje hodnoty NULL, proto musíme nějakou uvést, i když bude následně přepsána triggerem. To je nepříjmené, pojďme si náš trigger vylepšit! Funkci nebudeme volat po zápisu řádku, ale před zápisem (a v tuto chvíli si vygenerujeme oslovení).

CREATE FUNCTION concatenate() returns trigger AS $$
BEGIN
NEW.salutation := NEW.name || ' ' || NEW.surname;
return new;
END;
$$ LANGUAGE plpgsql;

S pomocí proměnné NEW přiřadíme oslovení. Hotovu funkci poté budeme volat před provedením INSERT nebo v případě UPDATE:

CREATE TRIGGER human_trigger BEFORE INSERT OR UPDATE ON human
 FOR EACH ROW EXECUTE PROCEDURE concatenate();

Silně a slabě typované jazyky

Typový systém může na problematiku nahlížet dvěma způsoby. Silně typované programovací jazyky striktně vyžadují pouze předem vymezené datové typy. Každá operace v takovém jazyce má proto určené jaké datové typy argumentů akceptuje. Do této kategorie patří např. Java nebo C.

Naopak tomu slabě typovaný jazyk se snaží operaci provést za každou cenu a proto přistupuje k přetypování. Vraťme se k příkladu z úvodu. Součet čísla a textového řetězce zdá se nedává smysl, ovšem co když v textu máme uložené opět číslo? Pak jazyku nic nebrání v tom, aby provedl přetypování textu na číslo a vypočítal výsledný součet. Ač se popsané chování může jevit jako jednoznačná výhoda, záleží na úhlu pohledu, někdy mohou díky této slabé kontrole datových typů vznikat hůře odhalitelné chyby. Popsaným způsobem se chová např. PHP nebo JavaScript.

Staticky a dynamicky typované jazyky

Programovací jazyk, který datové typy proměnných zjišťuje staticky, provádí vstupní analýzu kódu, během které je schopný odhalit datový typ každé proměnné. Napomáhá tomu mimo jiné to, že datový typ je zpravidla nutno deklarovat. Díky tomu pak překladač může lépe optimalizovat vytvářený kód (přesně totiž ví, s čím přichází do styku). Uvedené informace se vztahují k většině dnešních programovacích jazyků.

Existuje ovšem i jiný přístup. Co kdybychom datový typ zjistili až za běhu programu? Pak může jedna proměnná obsahovat několik naprosto rozdílných hodnot. Nemluvíme zde proto o typu proměnné (to platí pro staticky typované jazyky) ale o typu hodnoty. S uvedeným přístupem přichází např. jazyk Perl.

Bezpečně a nebezpečně typované jazyky

U bezpečně typovaných jazyků máme zajištěno, že pokud je operace proveditelná (tedy je splněna náležitost v podobě správných argumentů), tak vždy bude operace úspěšně dokončena. Nestane se zkrátka, že kvůli prováděné operaci aplikace spadne.

Naopak tomu jako už název prozrazuje nebezpečně typované jazyky dávají programátorovi šanci dostat výpočetní proces do nekonzistentního stavu. Díky existenci pointeru je poměrně jednoduché tohoto cíle dosáhnout v jazyce C nebo C++. Můžeme totiž různě přesouvat obsahy proměnných i obměňovat místa, kam v paměti ukazujeme.

void main()
{
    int *x = 0; //nulový ukazatel (NULL pointer)
    *x = 42; //chyba, na toto nulové místo se snažíme uložit hodnotu
}

Lexikální rozsah platnosti proměnné

Následujcí chování vám bude dobře známé. Používá jej totiž většina soudobých programovacích jazyků. Pokud se v nich rozhodnete aplikovat libovolnou proceduru obsahující ve svém těle proměnou neinicializovanou v lokálním prostředí této procedury, hledá se hodnota (vazba) proměnné v prostředí vzniku procedury. A co si představit pod pojmem prostředí vzniku procedury? Jde o prostředí nadřazené tomu lokálnímu. Důsledkem toho pokud v proceduře použijeme proměnnou, jejíž hodnota není v těle inicializována, je nutno vazbu hledat výše, kde s největší pravděpodobností narazíme na příslušnou globální proměnnou a z ní hodnotu vyčteme. Pokud by zde náhodou taková proměnná nebyla, nezbude než nahlásit chybu — proměnná totiž neexistuje.

Abychom to lépe pochopili, podívejme se nyní společně na komentovaný příklad:

(define test
  (lambda (y)
    (lambda (x)
      (+ y x))))

(define y 100);v globálním prostředí máme y = 100

(define f (test 20));vzniká procedura, nyní máme y = 20
(f 10);aplikace procedury, za x dosadíme 10 a spočítáme 20 + 10 = 30

;procedura ví, že má sečíst y a x
;hodnotu pro x zná (je to 10), tato hodnota byla předána v argumentu
;nyní je třeba zjistit hodnotu pro y, ta se totiž v lokálním prostředí nevyskytuje
;procedura tedy začíná hledat v "prostředí vzniku procedury", to je to prostředí, které je nadřazené tomu aktuálnímu
;v tomto nadřazeném prostředí je nalezeno kýžené y (s hodnotou 20)
;procedura sečte 20 + 10 a vrátí 30
;hodnota y = 100 v globálním prostředí je v tomto případě směle ignorována

Dynamický rozsah platnosti

A teď si představme, že by se hodnoty proměnných hledaly úplně jinak, konkrétně v prostředí aplikace procedury. Nutno podotknout, že tuto metodu téměř nikdo nepoužívá, ale existují výjimky. Než se podíváme na příklad, řekněme si, jaká je hlavní potíž tohoto přístupu — hodnoty proměnných zjistíme až za běhu programu, čímž stoupá časová náročnost ladění a hledání chyb.

(define test
  (lambda (y)
    (lambda (x)
      (+ y x))))

(define y 100);v globálním prostředí máme y = 100

(define f (test 20));vzniká procedura, nyní máme y = 20
(f 10);aplikace procedury, za x dosadíme 10 a spočítáme 100 + 10 = 110

;procedura ví, že má sečíst y a x
;hodnotu pro x zná (je to 10), tato hodnota byla předána v argumentu
;nyní je třeba zjistit hodnotu pro y, ta se totiž v lokálním prostředí nevyskytuje
;procedura tedy začíná hledat v "prostředí aplikace procedury"
;v tomto aktuálním prostředí se y = 100
;procedura sečte 100 + 10 a vrátí 110

Zmíněná mapa využívá tag map s atributem name, který je velmi důležitý, protože udává pojmenování, s jehož pomocí se následně klikací oblast propojí s obrázkem. Uvnitř mapy nalezneme tagy prozrazující konkrétní místa chovající se jako odkazy. Jejich cíl určuje href. Definovat se dále musí tvar prokliknutelného objektu s pomocí shape. Obvykle se zde nachází rect z anglického rectangular, tedy obdélník. Vytvořit lze dále i kruh. O nepravidelné tvary se postará hodnota polygon udávající nasazení mnohoúhelníku. Coords popisuje konkrétní pozici, v případě obdélníku zadáváte v pixelech souřadnice levého horního a pravého dolního rohu. U kruhu určíte pouze střed a poloměr. Jak správně tušíte, nejvíce práce nastává u mnohoúhelníku, kdy nezbývá než definovat jednotlivé body – vrcholy. Dosud jsem si však vždy vystačil s obyčejným obdélníkem.

Konkrétní HTML pak může vypadat například následovně:

<map name="JmenoMapy">
<area href="index.php" shape="rect" coords="5, 5, 20, 20">
<area href="login.php" shape="rect" coords="25, 25, 50, 50">
</map>

<img src="obrazek.png" usemap="#JmenoMapy" width="100" height="100">

Povšimněte si atributu usemap u obrázku, který s hashtagem odkazuje na mapu.

Tip na automatický nástroj

Dost bylo teorie, pojďme k praxi. Nic vám samozřejmě nebrání v nakódování potřebného HTML ručně, osobně však používám online pomůcku, která všechnu práci udělá za mě. Nachází se na image-maps.com a nejprve vás donutí nahrát obrázek, jehož mapu budete tvořit. S pomocí WYSIWYG rozhraní přetáhnete obdélníky na místa, jenž se mají stát odkazem a určíte jejich cíl (atribut href). Po dokončení je automaticky vygenerován HTML kód, který stačí jen zkopírovat. Obsahuje sice odkaz na použitý nástroj, nic vám však nebrání v jeho odstranění.

V NetBeans je potřeba nejprve otevřít soubor, jehož předchozí úpravy vás zajímají. Poté v menu vyberte Team -> Local History -> Show Local History. Zobrazí se přehledně zpracované porovnání aktuálního stavu se starou verzí. Snadno rozpoznáte přidané i odebrané řádky. Jakmile objevíte hledanou zálohu, využijte funkci Revert from History dostupnou po kliknutí pravým tlačítkem myši.

Lokální verzování zdrojových kódů jsem využil již několikrát, a proto tuto vlastnost IDE NetBeans považuji za velmi užitečnou. Drobnou výtku však mám k ukládání sedmidenní historie. U větších projektů by tato doba nemusela být dostačující, jednou jsem obnovoval šest dnů starý záznam. Poradím proto, jak zmíněné období uchovávání záloh prodloužit. Zavítejte do Tools -> Options -> Miscellaneous. Poté vyhledejte záložku Versioning a v levém menu zvolte History. Volbu Remove Local History files older than (number of days) následně navyšte dle svého uvážení.

Mailinator

První službu jsem již na tomto webu zmiňoval. Mailinator automaticky přivede k životu danou schránku a do ní zprávu doručí. S klidným svědomím jednoduše pošlete email na naprosto-cokoliv@mailinator.com, a poté ho zobrazíte na adrese naprosto-cokoliv.mailinator.com. Donedávna mi vadil ne příliš spolehlivý způsob zobrazování emailů v HTML. Mailinator však nedávno prošel faceliftem, který kromě obměny vzhledu přinesl ajaxové načítání obsahu schránky a hlavně podporu HTML zpráv. Vše funguje bez nutnosti předchozí registrace.

Gmail

K testovacím účelům lze překvapivě použít i Gmail, konkrétně jeden účet s jedinou emailovou adresou. Webová aplikace však u uživatelských účtů vyžaduje rozdílné emaily. Jak na to? Stačí používat tečky. Pokud se do webového rozhraní služby Gmail přihlašujete pomocí účtu jmeno.prijmeni@gmail.com, můžete jako svůj email uvádět jmenoprijmeni@gmail.com, j.m.e.n.o.p.r.i.j.m.e.n.i@gmail.com nebo jme.no.prij.meni@gmail.com. Nevěříte? Skutečně tak tomu je, a tvrdí to i Google, klidně si to vyzkoušejte. Nápověda uvádí tyto konkrétní tři případy, které mluví za vše:

• homerjsimpson@gmail.com = hom.er.j.sim.ps.on@gmail.com
• homerjsimpson@gmail.com = HOMERJSIMPSON@gmail.com
• homerjsimpson@gmail.com = Homer.J.Simpson@gmail.com

Nevýhodou tohoto řešení je však nutnost pamatovat si rozmístění teček pro jednotlivé uživatelské účty. Pokud vsadíte na Mailinator, vyhnete se uvedenému problému díky adresám typu administrator@mailinator.com, zakaznik@mailinator.com nebo dodavatel@mailinator.com.

V mém případě se překlad textu svěřil vyhledávacímu gigantovi Google. I když dokumentace popisuje nasazení API v mnoha programovacích jazycích, nenašel jsem kontaktování služby v PHP s parametry, které jsem požadoval. Dozajista se proto bude hodit, když ukáži, jakým způsobem text překládám.

require_once './google-api-php-client/src/Google_Client.php';
require_once './google-api-php-client/src/contrib/Google_TranslateService.php';

function translate($from, $to, $what)
{
$client = new Google_Client();
$client->setApplicationName('JmenoAplikace');  
$client->setDeveloperKey('123456789');
$service = new Google_TranslateService($client);

$translations = $service->translations->listTranslations($what, $to, array(
                "source" => $from,
                "format" => "html"
));
            
return $translations["translations"][0]["translatedText"];
}

Pro snadnější práci využívám knihovnu pojmenovanou Google API Client Library. Tu stačí stáhnout a rozbalit do zvoleného umístění. Ve zdrojovém kódu následně připojíte soubor Google_Client.php a zvolenou službu, kterou budete používat. Já chci překládat text, a proto se poohlédnu po Google_TranslateService.php ze složky contrib. Nasleduje vložení vývojářského klíče. Ten se dozvíte po přihlášení do Google API Console pod záložkou API Access konkrétního projektu. Zde hledejte část Simple API Access.

Nyní je na čase zavolat metodu, která obstará získání překladu. Já přitom znám původní jazyk i ten překládaný. Nepotřebuji proto, aby se jej Google snažil detekovat, v čemž ostatně u velmi krátkého překladu skládajícího se z jednoho slova ne vždy uspěje. Do parametrů $to a $from se jednoduše vloží ISO zkratka dle standardu 639-1, která má 2 znaky. Dále chci, aby Google přeložil text obsahující i HTML tagy tím způsobem, že je zachová. K tomu stačí specifikovat formát. Dle dokumentace se jako výchozí automaticky nastaví HTML, tento parametr tedy není nutno explicitně uvádět, alespoň ale budete mít představu kam sáhnout, když se rozhodnete chování překladu změnit.

Pokud dojde k chybě, vyhodí se výjimka Google_ServiceException. Já raději počítám i s Google_AuthException, Google_CacheException, Google_Exception a Google_IOException. Dále v případě reálného produkčního nasazení kontroluji, zda skutečně v polích existují příslušné indexy. K podobné opatrnosti mě poprvé donutilo API od Facebooku, kdy odpověď serveru ne vždy odpovídala tomu, co bylo uvedeno v dokumentaci.

Následující metoda představuje přímočarý postup, který však není funkční.

SELECT (1 + 1) as soucet, soucet + 1

Databáze u druhého sloupce ukončí provádění dotazu s tím, že nezná soucet, i když se jedná o alias předcházejícího sloupce.

Kýženého efektu dosáhneme díky proměnným. Těm se přiřazují hodnoty zápisem @jmeno:=hodnota. Aktuálně uchovávaný údaj vrátí @jmeno. Výše uvedený příklad by po nasazení proměnných vypadal takto:

SELECT @soucet:=(1 + 1) as soucet, @soucet + 1

Rázem získáváme číslo 2 a v druhém sloupci správný součet 3.

Samotná instalace je velmi jednoduchá, stačí stáhnout patřičný balík. Aplikace obsahuje mnoho předpřipravených prvků. Nabídka čítá součásti webových stránek, programů i mobilních aplikací. Připraveny jsou dále i základní elementy známé z vývojových diagramů. Ty sice nevytvářím, jednoduché geometrické tvary a šipky však usnadňují znázornění binárních vyhledávacích stromů.

Pencil má relativně intuitivní ovládání až na několik výjimek. Zpočátku mě velmi zaskočila nutnost jednotlivé prvky přetahovat. Čekal jsem, že k umístění bude potřeba využít kliknutí myši nebo kontextovou nabídku. Po chvíli se mi však metoda drag & drop dostala do krve. Dále jsem velmi dlouho hledal volbu k importu vlastního obrázku, například ve formátu PNG. Nakonec jsem vše vyřešil přetažením souboru z plochy přímo do pracovního prostředí. Až na tyto vady na kráse mě Pencil nezklamal a zmíněné nedostatky jsem proto aplikaci nakonec odpustil.

Tento článek představuje základní konstrukty jazyka Scheme. Uvedené informace se skvěle hodí k získání povědomí o některých dostupných procedurách a vybraných rysech jazyka.

Quote a quasiquote

Quote zabrání vyhodnocení výrazu. Lze zkráceně zapsat jako uvozoku ‚. Zápisy ‚szj.cz a (quote szj.cz) jsou tedy naprosto totožné. Quasiquote se chová shodně jako quote, můžeme si ale vyžádat vyhodnocení vybrané části výrazu. Ke zkrácení se používá symbol `.

‚szj.cz => szj.cz

(quote szj.cz) => szj.cz

`szj.cz => szj.cz

(quasiquote szj.cz) => szj.cz

Unquote a unquote-splicing

Z předchozího se může zdát, že mezi quote a quasiquote neexistuje rozdíl. Tak tomu však není. U výrazu uzavřeného v quasiquote vynutí unquote (zapisovano jako čárka „,„) vyhodnocení následující části.

`(szj.cz (+ 1 1) cz.szj) => (szj.cz (+ 1 1) cz.szj)

`(szj.cz ,(+ 1 1) cz.szj) => (szj.cz 2 cz.szj)

Quasiquote tedy označuje úsek, jenž se nikdy nezmění. Naopak tomu unquote symbolizuje přesný opak.

Dále lze využít unquote-splicing (symbol ,@) chovající se jako unquote, ale s výraznou změnou – výsledný seznam ztratí své vnější závorky.

`(,@`(1 2 3)) => (1 2 3)

Všechny dosud uvedené konstrukty obsahující ve svém názvu quote lze vzájemně vnořovat a kombinovat.

`(szj.cz `cz.szj 10) => (szj.cz `cz.szj 10)

`(szj.cz ,`cz.szj 10) => (szj.cz cz.szj 10)

Povšimněte si, že v následujícím zápisu nedojde k sečtení čísel 1 a 1.

`(szj.cz `(,(+ 1 1) cz.szj) 10) => (szj.cz `(,(+ 1 1) cz.szj) 10)

Unquote zde nebude fungovat, protože se nachází uvnitř druhého quasiquote nikoliv prvního. Po drobné úpravě však dosáhneme kýženého výsledku. Povolíme funkci druhého quasiquote a vše se již chová dle našeho přání.

`(szj.cz ,`(,(+ 1 1) cz.szj) 10) => (szj.cz (2 cz.szj) 10)

Seznam

Každý seznam se skládá ze dvou složek. K té první se přistupuje s pomocí car, druhou část vrátí cdr.

(car ‚(1 . 2)) => 1

(cdr ‚(1 . 2)) => 2

Pokud je druhá složek seznam, vypouští se tečka a závorky příležící k tomuto seznamu. Oba následující zápisy jsou proto totožné.

‚(((1))) => (((1)))

‚(((1).()).()) => (((1)))

O konstrukci páru se stará cons (bere v parametrech první a druhou složku).

(cons (cons (cons 1 ‚()) ‚()) ‚()) => (((1)))

(cons (cons 1 2) (cons 3 4)) => ((1 . 2) . (3 . 4)) => ((1 . 2) 3 . 4)

Car a cdr lze vzájemně sdružovat s pomocí předdefinovaných zkratek – např. cadr nejprve vykoná cdr a poté car, postupuje se tedy obráceně.

(cadr (cons (cons 1 2) (cons 3 4))) => 3

Build-list

Jako první parametr je očekávána délka budovaného seznamu, druhý parametr symbolizuje procedura, jenž bude aplikována na každý prvek nově vznikajícího seznamu, přičemž indexování začíná od nuly.

(build-list 5 -) => (0 -1 -2 -3 -4)

List-ref

Ze zadaného seznamu vrátí prvek na dané pozici. Indexování začíná od nuly.

(list-ref ‚(a b c d) 1) => b

Reverse a length

Jak již název napovídá, length zjišťuje délku seznamu, zatímco reverse provádí obrácení pořadí prvků.

(reverse ‚(a b c d)) => (d c b a)

(length ‚(a b c d)) => 4

Append

Vytváří nový seznam spojením libovolného množství zadaných seznamů.

(append ‚(1 2) ‚(3 4) ‚(5 6)) => (1 2 3 4 5 6)

Map

Aplikuje danou proceduru na každý prvek seznamu a vrátí výsledný seznam.

(map – ‚(1 2 3 4 5)) => (-1 -2 -3 -4 -5)

Pokud je zadáno více seznamů, prochází se postupně od začátku.

(map + ‚(1 2 3 4 5) ‚(1 2 3 4 5)) => (2 4 6 8 10)

Tento výčet nesymbolizuje to jediné, co jazyk Scheme nabízí. Jeho možnosti jdou totiž mnohem dál. K vyzkoušení uvedených příkladů potřebujete vhodný interpret, například Racket.