pondělí 27. října 2014

Relace a teorie relačních databází

Vítejte v prvním díle ze série kratkých článků o relačních databázích. Seriál je určen především pro vývojáře používající ORM, kteří nemají hlubší znalosti o relačních databázích.
Je třeba ještě zmínit, že v rámci zjednodušení a zrychlení výkladu se můžou v textu vyskytnout drobné formální nedokonalosti či nepřesnosti. Berte proto, prosím, uvedené teorie s nadhledem:)

Pěkně od začátku


Mějme nějakou běžnou, obyčejnou aplikaci:

Tato aplikace se skládá z několika částí:
  • UI - (uživatelské) rozhranní (WEB, GUI, WebServices apod.)
  • BL - business logika a datový model (který musí být persistentní)
  • ORM - vrstva ORM (framework, např. Hibernate)
  • RDB - relační databáze, úložište pro aplikaci
 A tato aplikace může řešit například evidenci zaměstnanců. Její zjednodušený datový model vypadá proto takto:

Nyní nastává ta správná otázka. Jak je v obrázku zakreslena relace (z pohledu relační databáze)?

Pokud je odpověď "relace je přece ta vidlička mezi tabulkama, ten vztah 1 ku N mezi entitami ....", čtěte dále, odpověď není zcela správná.

Proč? provedli jste záměnu dvou relativně podobných (nikoli totožných) pojmů:
  • Pojem "relation", jehož význam se chápe jako přirozený "vztah mezi subjekty" a který vnukne představu "vidličky" v modelu.
  • Pojem "relation", který se běžně překládá jako relace a který se užívá v matematice v teorii množin.
a právě relační databáze vychází z druhého uvedého pojmu. Než se posuneme k relačním databázím, bude vhodné si drobné základy z teorie množin připomenout.

Teorie množin

 

Z teorie množin si velmi lehce rozeberem čtyři pojmy:
  • množina
  • uspořádaná n-tice
  • kartézský součin
  • relace

Množiny není nutné nějak hluboce rozebírat. Mějme např. tyto možiny:
  • A = {“karel”, ”franta”, “pepa”}
  • B = {”franta”, “pepa”, “karel”}
  • C = {“karel”, “pepa”, 1,2}
  • D = {“karel”, “pepa”, 1,1,2}
S množinami je možné provádět různé operace (sjednocení, průnik...), možiny jsou navzájem disjunktní, konjuktní atd. atd.

Důležité jsou však dvě vlastnosti obecných množin:
  • Nezáleží na pořadí prvků v množině (tedy platí A=B).
  • Každý prvek může být v množině max. jednou (tedy platí C=D).
A zde se dostáváme k uspořádaným n-ticím:
Uspořádaná n-tice vypadá na první pohled jako klasická množina, oproti výše popsané množině má právě tyto speciální vlastnosti:
  • Záleží na pořadí prvků v množin.
  • Každý prvek se může v n-tici opakovat.
 Proto pokud bychom měli tyto uspořádané n-tice (zapisované v hranatých závorkách)
  • A = [“karel”, ”franta”, “pepa”]
  • B = [”franta”, “pepa”, “karel”]
  • C = [“karel”, “pepa”, 1,2]
  • D = [“karel”, “pepa”, 1,1,2]
tak v porovnání s množinám již neplatí rovnost A a B, a C a D, což se nám hodí pro vysvětlení dalšího pojmu: kartézský součin.

Kartézksý součin lze poměrně složitě definovat, pro jedoduchost ho popíšem slovně selským rozumem a příkladem:

Kartézksý součin dvou množin A a B je množina uspořádaných dvojic vytvořená jako "každý prvek z A s každým prvkem B".


Příklad 1 (z wikipedie):
pokud A = {x, y, z} a B = {1, 2, 3} pak 
AxB = { [x,1],[x,2],[x,3],[y,1],[y,2],[y,3],[z,1],[z,2],[z,3] }



Další praktičtější příklad (rovněž z wikipedie), který popisuje hrací karty:  
  • A = { sedma, osma, devítka, desítka, spodek, svršek, král, eso} 
  • B = { srdce, listy, kule, žaludy }

Výsledek: 
A × B = {  [sedma,   srdce   ],
       [sedma,   listy   ],
       [sedma,   kule    ],
       [sedma,   žaludy  ],
       [osma,    srdce   ],
        …,
       [eso,     kule    ],
       [eso,     žaludy  ]}.
 
Jak je vidět, kartézský součin nám v tomto případě definoval celý hrací balíček karet, ve kterém je jedna karta tvořená uspořádanou dvojcí [číslo, barva].

Ted je čas na poslední zajímavý pojem, pojem jež dal relačním databázím jméno - relace. Definice je velice jednoduchá a zní:

Relace je podmožina kartézského součinu.
 

 

Samo o sobě to nezní užitečně, ovšem můžem si ukázat nějaké příklady relace z kartézským součinu vytvořeného v předchozím příkladu:

R1 = { [sedma,   srdce    ],
       [devítka, žaludy   ], 

       [svršek,  kule     ]} 

R2 = { [sedma,   srdce    ],
       [devítka, žaludy   ],
       [svršek,  žaludy   ],
       [desítka, kule     ],
       [eso,     kule     ]}

Takto definované relace nám můžou představovat jakoukoliv část balíčku (například karty hráče, talón či nerozdané karty). Důležité je, že relace je množina, takže s ní můžeme formálně provádět operace jako sjednocení. odečtení, porovnání apod.

Pokud se podíváme na relace R1 a R2 příkladu karetních her, možná nám nápadně pripomínají ještě něco - ano, tabulky. Pověstné tabulky které jsou srdcem všech relačních databází, tabulkových procesorů a kostičkových papírů. Relace R1 i R2 vypadají jako tabulky, buď dvě různé a nebo se může jednat o jednu a tu samou tabulku v jiném čase. 

Nyní je čas se podívat zpátky k úvodní otázce ze začátku kapitoly: Jak je v obrázku zakreslená relace (z pohledu relační databáze)? Odpověď je tedy "tabulkou". Již zmíněné "vydličky", tedy vztahy mezi tabulkami, nejsou v původním slova smyslu relace.



Teorie relačních databází, relační algebra


K plnému využití relačních databází je nutné pochopit, na jakém principu byly tyto databáze postaveny. V předchozí části jsme si ukázali, z jakého matematického základu relační databáze čerpají. Nyní se posuneme z matematické teorie do teorie relačních databází.

Základy relačních databází definoval pan Edgar F. Codd kolem roku 1970 ve své práci "A Relational Model of Data for Large Shared Data Banks". V této práci formalizoval relační model, relace (tabulky) a  definoval tzv. relační algebru.


Nemá smysl zacházet příliš do hloubky, je však vhodné uvést operátory relační algebry, které se používají pro práci s relacemi:
  • Selection (výběr, selekce)
  • Projection (projekce)
  • Inner and outer joins (sjednocení)
  • Division (rozdíl)
  • Cartesian product (kartézský součin)
  • Rename (přejmenování )
Vstupem do operátoru jsou relace, výstupem jsou (to je velice důležité) rovněž relace. Díky tomu lze operátory a relace libovolně skládat a řetězit stejně, jako jsme zvyklí u běžných matematických operátoru a vytvořit komplexní výrazy.

Relační algebra je implementována v relační databázi a zapisuje se pomocí SQL takto:

select <projection>
from   <relation>,<relation>… (kartézský součin)
where  <selection>
inner/outer join <relations>
union  <relation> 


Jak je vidět, každý sql dotaz se v databázi interpretuje jako sada relačních operátorů nad tabulkami (relacemi), kde výsledkem je opět relace. SQL dotazy lze tedy libovolně skládat, používat několikásobně vnořené selekty a vůbec provádět všeljaká kouzla.

Závěr


Ukázali jsme si základy teorie množin a relačních databází, čímž jsme si otevřeli cestu do praxe. V dalších dílech se objeví ukázky, které uvedenou teorii maximálně využijí. Příkady budou psány pro databízi Oracle, ale principiálně fungují stejně téměř ve všech relačníc databázích. Tak si je nenechte ujít:)

David

pátek 18. července 2014

ORM skrývá pravou sílu relačních db

Úvod

Přestoupil jsem z dobře zajeté staré firmy pracují tradičním způsobem let devadesátých  (Oracle Forms a RDB, částečně Java1.4 či 5), do mladé, agilnější firmy používající modernější a více sexy nástroje (např. Java7, OSGi, Vaadin...).

Zde bylo krásně vidět, jak se posouvají trendy ve vývoji aplikací a jaký je rozdíl v přemýšlení mladých a starších vývojářů.

Jedním takovým ukázkovým příkladem je použití objektově relačního mapování (ORM):
  • Ve firmě "ze staré školy" se kladl veliký důraz na relační databázi. Systémy byly obvykle psané v PL\SQL a v Javě tak, aby obě technologie byly v symbióze - Náročné datové operace se soustředily do databáze, uživatelské rozhraní do Javy. ORM byl "pouze" druhotný nástroj pro snažší propojení těchto technologií.
  • Naproti tomu nadšení vývojáři v mladé firmě všechny úlohy systému soustředí jen a jen do Javy. ORM se stalo středobodem datové struktury a relační databáze je pouze skrytým úložištěm.
Nemusím ani naznačovat, že v produkčním prostředí se s rostoucími daty začaly vznikat vážné výkonnostní problémy způsobené chybějícími indexy, neefektivními dotazy a někdy i nevhodnými  programátorskými postupy.

A právě to mě přivedlo k zamyšlení se nad příčinou vzniku celé věci:

Automatickým přidáním ORM vrstvy do systému se vývojáři velice zjednodušil svět. Vytvořit a udržovat datový model aplikace se zmenšil na pár anotací v POJO objektu, kde všechno funguje snadno a automaticky. K vývoji stačí několik málo jednoduchých metod typu findByXXX a systém (v laboratorních podmínkách) běží jako po másle. Dochází k jakémusi "přeskočení" principů relační databáze a vkročení rovnou do světa Javy. Pro vývojáře je pohodlnější iterovat a filtrovat nad výsledkem dotazu než napsat takový dotaz, aby dostal do Javy jen minimální potřebné záznamy.

Právě proto jsem se rozhodl v naší firmě provést menší osvětu v podobě školní s ukázkami a předvést i méně zkušeným kolegům, co všechno se dá v relační databázi dělat a k čemu vlastně relační db původně sloužily. 

Výsledkem mého snažení se stala zajímavá sada jednoduchých ukázek, ze kterých bych rád vytvořil krátký seriál.

Jednotlivá témata:

  1. Relace a teorie relačních databází
  2. Tabulka dual
  3. Práce s časem
  4. Hrací karty
  5. Analytické funkce
  6. Rekurze v SQL



středa 9. dubna 2014

Kai Tödter's modular application on Eclipse Virgo


Kai Tödter's modular application on Eclipse Virgo

We are looking for suitable technologies for our new project - modular web platform.
Because we like Vaadin and OSGi, we did some research and look ups for technologies based on these frameworks.

We have found two nice things on the internet:




I decided to do some modifications for our project purposes:
  • Maven based project
  • Eclipse Virgo development and deployment ready
  • Get rid of HttpService, use standard WAB (web application bundle)
  • Get rid of Declarative services use Gemini blueprint
I also made some simplifications: I didn't adopt all of original modules and I integrated additional vaadin bundles (org.vaadin.osgi.staticres, org.vaadin.osgi) into main application bundle. Result of my efforts you can download here:

>> Download example com.siemens.ct.osgi.vaadin.pm.zip  <<

Note: This example has some imperfections (some pom.xml refactiong is needed, old vaadin version, some strange behaviors in example....) but for learning purposes is enought, I guess:).

Guide 1 - simple deploy

  1. Download eclipse virgo with jetty 3.6.2 - http://www.eclipse.org/downloads/download.php?file=/virgo/release/VP/3.6.2.RELEASE/virgo-jetty-server-3.6.2.RELEASE.zip
  2. Unzip virgo.
  3. Download com.siemens.ct.osgi.vaadin.pm.zip
  4. unzip
  5. mvn clean install (in <sample_dir>)
  6. Start virgo via <virgo_dir>\bin\startup.bat (wait till virgo is ready)
  7. Copy into <virgo_dir>\pickup those files (KEEP ORDER!!!)
    1. <sample_dir>\vaadin-6.7.6.jar
    2. <sample_dir>\main\target\com.siemens.ct.osgi.vaadin.pm.main-1.0.0-SNAPSHOT.jar
    3. <sample_dir>\printaction\target\com.siemens.ct.osgi.vaadin.pm.printaction-1.0.0.qualifier.jar
    4. <sample_dir>\runoaction\target\com.siemens.ct.osgi.vaadin.pm.runoaction-1.0.0.qualifier.jar
    5. <sample_dir>\bundleview\target\com.siemens.ct.osgi.vaadin.pm.bundleview-1.0.0.qualifier.jar
  8. open url http://localhost:8080/producer/main
  9. Enjoy

Guide 2 - Eclipse tool

  1. Download eclipse virgo with jetty 3.6.2 - http://www.eclipse.org/downloads/download.php?file=/virgo/release/VP/3.6.2.RELEASE/virgo-jetty-server-3.6.2.RELEASE.zip
  2. Unzip virgo.
  3. Download com.siemens.ct.osgi.vaadin.pm.zip
  4. mvn clean install in <sample_dir>
  5. Copy into <virgo_dir>\repository\usr file <sample_dir>\vaadin-6.7.6.jar
  6. Start Eclipse (Kepler), install Virgo Eclipse Tool according to http://wiki.eclipse.org/Virgo/Tooling
  7. Import via  "Existing maven project" projects from directory <sample_dir>. Use project template "groupId"."artefactId"
  8. Add Virgo Nature to imported projects (except project com.siemens.ct.osgi.vaadin.pm)
    1. Select projects in "Package Explorer", right click for context menu -> Virgo -> Add bundle project nature.
  9. Add new server Runtime (Windows -> Preferences -> Server -> Runtime -> Add "EclipseRT\Virgo Runtime". Put <virgo_dir>
  10. Add new server in "Servers" window ->Create New Server -> "EclipseRT\Virgo Runtime", host name "localhost", select your runtime from step 8 as runtime.
  11. Next button
  12. Add application"com.siemens.ct.osgi.vaadin.pm.main" only!.
  13. Start your server in "Servers" window.
  14. open url http://localhost:8080/producer/main
  15. Add other applications (right click on your server in "Servers" window)