Svet databáz už dávno ovládli relačné SODB, v ktorých sa používa jazyk SQL. Je to tak silné, že sa objavujú aj varianty nazývané NoSQL. Týmto sa podarilo získať určitý priestor na tomto trhu, ale relačné SODB rozhodne neplánujú vymrieť a naďalej sa intenzívne používajú na svoje ciele.
V tomto článku chcem popísať koncept funkčnej databázy. Na lepšie pochopenie to spravím porovnaním s klasickým relačným modelom. Ako príklady budú použité úlohy z rôznych testov SQL, ktoré sa dajú nájsť na internete.
Úvod
Relačné databázy operujú s tabuľkami a poliami. V funkčnej databáze ich namiesto toho nahradia triedy a funkcie. Pole v tabuľke s N kľúčmi bude reprezentované ako funkcia s N parametrami. Namiesto vzťahov medzi tabuľkami sa použijú funkcie, ktoré vrátia objekty triedy, na ktorú sa vzťahujú. Namiesto JOIN sa použije kompozícia funkcií.
Predtým, ako prejdeme priamo k úlohám, opíšem úlohu doménovej logiky. Pre DDL použijem syntax PostgreSQL. Pre funkčnú vlastný syntax.
Tabuľky a polia
Jednoduchý objekt Sku s poliami názov a cena:
Grafový, dokumentový
CREATE TABLE Sku
(
id bigint NOT NULL,
name character varying(100),
price numeric(10,5),
CONSTRAINT id_pkey PRIMARY KEY (id)
)
Funkčná
CLASS Sku;
name = DATA STRING[100] (Sku);
price = DATA NUMERIC[10,5] (Sku);
Označíme dve funkcie, ktoré prijímajú jeden parameter Sku a vracajú primárny typ.
Predpokladá sa, že v funkčnej SODB bude mať každý objekt nejaký vnútorný kód, ktorý sa automaticky generuje, a na ktorý sa dá v prípade potreby odvolať.
Určíme cenu pre výrobok / obchod / dodávateľa. Môže sa v priebehu času meniť, preto do tabuľky pridáme pole čas. Deklaráciu tabuliek pre referenčné údaje v relačnej databáze preskočím, aby som skrátil kód:
Grafový, dokumentový
CREATE TABLE prices
(
skuId bigint NOT NULL,
storeId bigint NOT NULL,
supplierId bigint NOT NULL,
dateTime timestamp without time zone,
price numeric(10,5),
CONSTRAINT prices_pkey PRIMARY KEY (skuId, storeId, supplierId)
)
Funkčná
CLASS Sku;
KLASA Obchod;
KLASA Dodávateľ;
dateTime = ÚDAJ DATETIME (Sku, Obchod, Dodávateľ);
cena = ÚDAJ NUMERIC[10,5] (Sku, Obchod, Dodávateľ);
Indexy
Pre posledný príklad vytvoríme index na všetkých kľúčoch a dátume, aby sme mohli rýchlo nájsť cenu v určenom čase.
Grafový, dokumentový
CREATE INDEX prices_date
ON prices
(skuId, storeId, supplierId, dateTime)
Funkčná
INDEX Sku sk, Obchod st, Dodávateľ sp, dateTime(sk, st, sp);
Úlohy
Začneme s relatívne jednoduchými úlohami, ktoré sú prevzaté z príslušných na Habr.
Najprv vyhlásime doménovú logiku (pre relačnú databázu je to vykonané priamo v uvedenom článku).
KATEGÓRIA Oddelenie;
meno = ÚDAJOVÝ REŤAZEC[100] (Oddelenie);
CLASS Employee;
department = DATA Department (Employee);
chief = DATA Employee (Employee);
name = DATA STRING[100] (Employee);
salary = DATA NUMERIC[14,2] (Employee);
Úloha 1.1
Vypíšte zoznam zamestnancov, ktorých mzda je vyššia než u priamo nadriadeného.
Grafový, dokumentový
select a.*
from employee a, employee b
where b.id = a.chief_id
and a.salary > b.salary
Funkčná
VYBER názov(Zamestnanec a) KDE plat(a) > plat(šéf(a));
Úloha 1.2
Vypíšte zoznam zamestnancov, ktorí majú najvyšší plat vo svojom oddelení
Grafový, dokumentový
select a.*
from employee a
where a.salary = ( select max(salary) from employee b
where b.department_id = a.department_id )
Funkčná
maxSalary 'Maximálna mzda' (Oddelenie s) =
GROUP MAX mzda(Zamestnanec e) IF oddelenie(e) = s;
SELECT meno(Zamestnanec a) WHERE mzda(a) = maxSalary(oddelenie(a));
// или если "заинлайнить"
SELECT name(Employee a) WHERE
salary(a) = maxSalary(GROUP MAX salary(Employee e) IF department(e) = department(a));
Obe realizácie sú ekvivalentné. Pre prvý prípad v relačnej databáze je možné použiť CREATE VIEW, ktorý rovnako najprv vypočíta pre konkrétne oddelenie maximálnu mzdu v ňom. Následne budem pre prehľadnosť používať prvý prípad, pretože lepšie odráža riešenie.
Úloha 1.3
Vypíšte zoznam ID oddelení, v ktorých počet zamestnancov nepresahuje 3 osoby.
Grafový, dokumentový
select department_id
from employee
group by department_id
having count(*) <= 3
Funkčná
pocetZamestnancov 'Počet zamestnancov' (Oddelenie d) =
GROUP SUM 1 IF department(Employee e) = d;
SELECT Oddelenie d WHERE pocetZamestnancov(d) <= 3;
Úloha 1.4
Vypíšte zoznam zamestnancov, ktorí nemajú prideleného nadriadeného, pracujúceho v tom istom oddelení.
Grafový, dokumentový
select a.*
from employee a
left join employee b on (b.id = a.chief_id and b.department_id = a.department_id)
where b.id is null
Funkčná
VYBER meno(Zamestnanec a) KDE NE (department(šéf(a)) = department(a));
Úloha 1.5
Nájdite zoznam ID oddelení s maximálnou súhrnnou mzdou zamestnancov.
Grafový, dokumentový
with sum_salary as
( select department_id, sum(salary) salary
from employee
group by department_id )
select department_id
from sum_salary a
where a.salary = ( select max(salary) from sum_salary )
Funkčná
salarySum 'Maximálna mzda' (Oddelenie d) =
GROUP SUM salary(Employee e) IF department(e) = d;
maxSalarySum 'Maximálna mzda oddelení' () =
GROUP MAX salarySum(Oddelenie d);
SELECT Oddelenie d WHERE salarySum(d) = maxSalarySum();
Prejdeme k zložitejším úlohám z iného . Obsahuje podrobnú analýzu toho, ako realizovať túto úlohu na MS SQL.
Úloha 2.1
Ktorí predajcovia predali v roku 1997 viac ako 30 kusov tovaru č. 1?
Doménová logika (ako predtým na RDBMS vynechávame vyhlásenie):
CLASS Employee 'Predavač';
lastName 'Priezvisko' = DATA STRING[100] (Employee);
CLASS Product 'Produkt';
id = DATA INTEGER (Product);
name = DATA STRING[100] (Product);
CLASS Order 'Objednávka';
date = DATA DATE (Order);
employee = DATA Employee (Order);
CLASS Detail 'Položka objednávky';
order = DATA Order (Detail);
product = DATA Product (Detail);
quantity = DATA NUMERIC[10,5] (Detail);
Grafový, dokumentový
select LastName
from Employees as e
where (
select sum(od.Quantity)
from [Order Details] as od
where od.ProductID = 1 and od.OrderID in (
select o.OrderID
from Orders as o
where year(o.OrderDate) = 1997 and e.EmployeeID = o.EmployeeID)
) > 30
Funkčná
predaj (Zamestnanec e, INTEGER productId, INTEGER rok) =
GROUP SUM množstvo (DetailObjednávky d) IF
zamestnanec (objednávka(d)) = e A
id(product(d)) = productId A
vyberRok (dátum(objednávka(d))) = rok;
VYBER lastName (Zamestnanec e) KDE predaj(e, 1, 1997) > 30;
Úloha 2.2
Pre každého kupujúceho (meno, priezvisko) nájdite dva produkty (názov), na ktoré kupujúci v roku 1997 vynaložil najviac peňazí.
Rozširujeme doménovú logiku z predchádzajúceho príkladu:
CLASS Customer 'Zákazník';
contactName 'Meno a priezvisko' = DATA STRING[100] (Zákazník);
zákazník = DATA Zákazník (Objednávka);
cenaJednotky = DATA ČÍSELNÝ[14,2] (Detail);
zľava = DATA ČÍSELNÝ[6,2] (Detail);
Grafový, dokumentový
SELECT ContactName, ProductName FROM (
SELECT c.ContactName, p.ProductName
, ROW_NUMBER() OVER (
PARTITION BY c.ContactName
ORDER BY SUM(od.Quantity * od.UnitPrice * (1 - od.Discount)) DESC
) AS RatingByAmt
FROM Customers c
JOIN Orders o ON o.CustomerID = c.CustomerID
JOIN [Order Details] od ON od.OrderID = o.OrderID
JOIN Products p ON p.ProductID = od.ProductID
WHERE YEAR(o.OrderDate) = 1997
GROUP BY c.ContactName, p.ProductName
) t
WHERE RatingByAmt < 3
Funkčná
súčet (Detail d) = množstvo(d) * cenaZaJednotku(d) * (1 - zľava(d));
kúpil 'Kúpil' (Zákazník c, Produkt p, ČÍSLO y) =
SKUPINOVÝ ZOZNAM súčtov(Detail d) AK
zákazník(objednávka(d)) = c A
produkt(d) = p A
extrakciaRok(date(order(d))) = y;
hodnotenie 'Hodnotenie' (Zákazník c, Produkt p, ČÍSLO y) =
PARTÍCIA SÚČET 1 PORADIE DESC zakúpené(c, p, y), p PODĽA c, y;
VYBERTE contactName(Zákazník c), name(Produkt p) KDE hodnotenie(c, p, 1997) < 3;
Operátor PARTITION funguje na nasledujúcom princípe: sčíta výraz uvedený za SUM (tu 1) v rámci určených skupín (tu Zákazník a Rok, ale môže to byť akýkoľvek výraz), zoradí v rámci skupín podľa výrazov uvedených v ORDER (tu kúpené, a ak sú rovné, tak podľa interného kódu produktu).
Úloha 2.3
Koľko výrobkov je potrebné objednať od dodávateľov na splnenie aktuálnych objednávok.
Opäť rozširujeme doménovú logiku:
CLASS Supplier 'Dodávateľ';
companyName = DATA STRING[100] (Dodávateľ);
dodávateľ = DATA Dodávateľ (Produkt);
jednotkyNaSklade 'Zostávajúce na sklade' = DATA ČÍSELNÝ[10,3] (Produkt);
úroveňObjednania 'Norma predaja' = DATA ČÍSELNÝ[10,3] (Produkt);
Grafový, dokumentový
select s.CompanyName, p.ProductName, sum(od.Quantity) + p.ReorderLevel - p.UnitsInStock as ToOrder
from Orders o
join [Order Details] od on o.OrderID = od.OrderID
join Products p on od.ProductID = p.ProductID
join Suppliers s on p.SupplierID = s.SupplierID
where o.ShippedDate is null
group by s.CompanyName, p.ProductName, p.UnitsInStock, p.ReorderLevel
having p.UnitsInStock < sum(od.Quantity) + p.ReorderLevel
Funkčná
objednané, ale neodoslané (Produkt p) =
SKUPINOVÉ SUMA množstvo(OrderDetail d) AK produkt(d) = p;
kObjednaniu (Produkt p) = objednané, ale neodoslané(p) + úroveňObjednania(p) - jednotkyNaSklade(p);
VYBRAŤ názovSpoločnosti(dodávateľ(Produkt p)), názov(p), kObjednaniu(p) KDE kObjednaniu(p) > 0;
Úloha so hviezdičkou
A posledný príklad osobne odo mňa. Existuje logika sociálnej siete. Ľudia si môžu byť priateľmi a mať sa radi. Z pohľadu funkčnej databázy by to vyzeralo takto:
CLASS Osoba;
likes = DATA BOOLEAN (Osoba, Osoba);
friends = DATA BOOLEAN (Osoba, Osoba);
Je potrebné nájsť možných kandidátov na priateľstvo. Formálnejšie je potrebné nájsť všetkých ľudí A, B, C tak, že A je priateľ s B, B je priateľ s C, A má rád C, ale A nie je priateľ s C.
Z pohľadu funkčnej databázy by dotaz vyzeral takto:
VYBER Osobu a, Osobu b, Osobu c KDE
má rád(a, c) A NIE sú priateľmi(a, c) A
sú priateľmi(a, b) A sú priateľmi(b, c);
Čitateľovi sa navrhuje, aby si sám vyriešil túto úlohu na SQL. Predpokladá sa, že priateľov je oveľa menej ako tých, ktorí sa majú radi. Preto sú v oddelených tabuľkách. V prípade úspešného riešenia je tu aj úloha s dvoma hviezdičkami. V nej priateľstvo nie je symetrické. Na funkčnej databáze by to vyzeralo takto:
VYBER Osobu a, Osobu b, Osobu c KDE
má rád(a, c) A NIE sú priateľmi(a, c) A
(priatelia(a, b) OR priatelia(b, a)) AND
(priatelia(b, c) OR priatelia(c, b));
UPD: riešenie úlohy s prvou a druhou hviezdičkou od :
VYBERTE
pl.PersonAID
,pf.PersonAID
,pff.PersonAID
Z Osôb AS p
--Lajky
PRIPOJIŤ PersonRelationShip AS pl ON pl.PersonAID = p.PersonID
A pl.Relácia = 'Lajk'
--Priatelia
PRIPOJIŤ PersonRelationShip AS pf ON pf.PersonAID = p.PersonID
A pf.Relácia = 'Priateľ'
--Priatelia priateľov
PRIPOJIŤ PersonRelationShip AS pff ON pff.PersonAID = pf.PersonBID
A pff.PersonBID = pl.PersonBID
A pff.Relácia = 'Priateľ'
--Ešte nie sú priatelia
ĽAVO PRIPOJIŤ PersonRelationShip AS pnf ON pnf.PersonAID = p.PersonID
A pnf.PersonBID = pff.PersonBID
A pnf.Relácia = 'Priateľ'
KDE pnf.PersonAID IS NULL
;S WITH PersonRelationShipCollapsed AS (
VYBERTE pl.PersonAID
,pl.PersonBID
,pl.Relácia
Z #PersonRelationShip AS pl
ZLÚČIŤ
VYBERTE pl.PersonBID AS PersonAID
,pl.PersonAID AS PersonBID
,pl.Relácia
Z #PersonRelationShip AS pl
)
VYBERTE
pl.PersonAID
,pf.PersonBID
,pff.PersonBID
Z #Osob AS p
--Lajky
PRIPOJIŤ PersonRelationShipCollapsed AS pl ON pl.PersonAID = p.PersonID
A pl.Relácia = 'Lajk'
--Priatelia
PRIPOJIŤ PersonRelationShipCollapsed AS pf ON pf.PersonAID = p.PersonID
A pf.Relácia = 'Priateľ'
--Priatelia priateľov
PRIPOJIŤ PersonRelationShipCollapsed AS pff ON pff.PersonAID = pf.PersonBID
A pff.PersonBID = pl.PersonBID
A pff.Relácia = 'Priateľ'
--Ešte nie sú priatelia
ĽAVO PRIPOJIŤ PersonRelationShipCollapsed AS pnf ON pnf.PersonAID = p.PersonID
A pnf.PersonBID = pff.PersonBID
A pnf.Relácia = 'Priateľ'
KDE pnf.[PersonAID] IS NULL
Záver
Je potrebné poznamenať, že uvedená syntax jazyka je len jednou z možností implementácie danej koncepcie. Ako základ bol použitý SQL a cieľom bolo, aby bol čo najviac podobný. Samozrejme, niektorým sa môžu nepáčiť názvy kľúčových slov, registre a ďalšie. Hlavné je, že ide o samotnú koncepciu. Pri želaní je možné vytvoriť aj C++ a Python s podobnou syntaxou.
Opísaná koncepcia databázy, podľa môjho názoru, má nasledujúce výhody:
- Jednoduchosť. Je to relatívne subjektívny ukazovateľ, ktorý nie je zrejmý pri jednoduchých prípadoch. Ale ak sa pozrieme na zložitejšie prípady (napríklad úlohy so hviezdičkami), tak, podľa môjho názoru, písanie takýchto dotazov je oveľa jednoduchšie.
- Zapuzdrenie. V niektorých príkladoch som vyhlasoval medzičlánkové funkcie (napríklad, predané, kúpené a podobne), na ktorých sa budovali nasledujúce funkcie. To umožňuje, ak je to potrebné, zmeniť logiku určitých funkcií bez zmeny logiky závislých od nich. Napríklad, je možné urobiť tak, aby predaje predané považovali za úplne iné objekty, pričom zvyšná logika sa nezmení. Áno, v RDBMS to možno realizovať pomocou CREATE VIEW. Ale ak napíšete celú logiku týmto spôsobom, bude to vyzerať nie veľmi čitateľne.
- Nedostatok sémantického rozporu. Takáto databáza operuje s funkciami a triedami (namiesto tabuliek a polí). Rovnako ako v klasickom programovaní (ak vezmeme do úvahy, že metóda je funkcia s prvým parametrom ako trieda, ku ktorej patrí). Podľa toho by malo byť „pripojenie“ k univerzálnym programovacím jazykom oveľa jednoduchšie. Okrem toho táto koncepcia umožňuje realizovať oveľa zložitejšie funkcie. Napríklad možno vložiť do databázy operátory typu:
CONSTRAINT sold(Employee e, 1, 2019) > 100 IF name(e) = 'Petr' MESSAGE 'Niečo Peter predáva príliš veľa jedného tovaru v roku 2019.';
- Dedičstvo a polymorfizmus. Vo funkčnej databáze možno zaviesť viacnásobné dedičstvo cez konštrukcie CLASS ClassP: Class1, Class2 a realizovať viacnásobný polymorfizmus. Ako presne, možno napíšem v nasledujúcich článkoch.
Napriek tomu, že ide len o koncepciu, máme už nejakú realizáciu v Jave, ktorá prekladá celú funkčnú logiku do relačnej logiky. Plus k nej je krásne pripojená logika prezentácií a veľa ďalšieho, vďaka čomu vzniká celá . V podstate používame RDBMS (zatiaľ len PostgreSQL) ako „virtuálnu stroj“. Pri takomto preklade občas vznikajú problémy, pretože optimalizátor dotazov RDBMS nepozná špecifickú štatistiku, ktorú pozná FDBMS. Teoreticky je možné realizovať systém riadenia databázy, ktorý by používal ako úložisko nejakú štruktúru, prispôsobenú práve pre funkčnú logiku.
Zdroj: habr.com
