Funkcionálna DBMS

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 článku 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 článku. 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 dss_kalika:

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á platforma. 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

Kúpte si spoľahlivý hosting pre webové stránky s ochranou proti DDoS, VPS VDS servery 🔥 Kúpte si spoľahlivý hosting pre webové stránky s ochranou proti DDoS, VPS VDS servery | ProHoster