DatabasmvÀrlden har lÀnge dominerats av relationsdatabaser som anvÀnder SQL. SÄ mycket att de nya varianterna kallas NoSQL. De har lyckats fÄ en viss plats pÄ denna marknad, men relationsdatabaserna Àr inte pÄ vÀg att dö ut och anvÀnds fortfarande aktivt för sina syften.
I den hÀr artikeln vill jag beskriva konceptet med funktionella databaser. För att underlÀtta förstÄelsen kommer jag att göra detta genom att jÀmföra med den klassiska relationsmodellen. Exempel pÄ olika uppgifter frÄn SQL-tester som hittats pÄ internet kommer att anvÀndas.
Introduktion
Relationsdatabaser arbetar med tabeller och kolumner. I en funktionell databas kommer klasser och funktioner att anvÀndas istÀllet. En kolumn i en tabell med N nycklar kommer att representeras som en funktion av N parametrar. IstÀllet för relationer mellan tabeller kommer funktioner att anvÀndas som returnerar objekten av den klass som relationen pekar pÄ. IstÀllet för JOIN kommer funktionskomposition att anvÀndas.
Innan vi gÄr direkt till uppgifterna kommer jag att beskriva uppgiftens domÀnlogik. För DDL kommer jag att anvÀnda PostgreSQL-syntax. För funktionell databas kommer min egen syntax att anvÀndas.
Tabeller och kolumner
Ett enkelt objekt Sku med fÀlten namn och pris:
Relational
CREATE TABLE Sku
(
id bigint NOT NULL,
name character varying(100),
price numeric(10,5),
CONSTRAINT id_pkey PRIMARY KEY (id)
)
Funktionell
KLASS Sku;
namn = DATA STRĂNG[100] (Sku);
pris = DATA NUMERISK[10,5] (Sku);
Vi deklarerar tvÄ funktioner, som tar ett parameter Sku som indata och returnerar en primitiv typ.
Det antas att varje objekt i en funktionell databas har en intern kod som automatiskt genereras och som kan anvÀndas vid behov.
Vi sÀtter ett pris för produkt/en butik/en leverantör. Det kan förÀndras över tid, sÄ vi lÀgger till ett tidsfÀlt i tabellen. Jag kommer att hoppa över deklarationen av tabeller för referenstabeller i den relationsdatabasen för att korta ner koden:
Relational
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)
)
Funktionell
KLASS Sku;
Klass Butik;
Klass Leverantör;
datumTid = DATA DATUMTID (Sku, Butik, Leverantör);
pris = DATA NUMERISK[10,5] (Sku, Butik, Leverantör);
Index
För det sista exemplet skapar vi ett index pÄ alla nycklar och datum sÄ att vi snabbt kan hitta priset vid en viss tidpunkt.
Relational
CREATE INDEX prices_date
ON prices
(skuId, storeId, supplierId, dateTime)
Funktionell
INDEX Sku sk, Butik st, Leverantör sp, dateTime(sk, st, sp);
Uppgifter
Vi börjar med relativt enkla uppgifter hÀmtade frÄn motsvarande pÄ Habr.
Först deklarerar vi domÀnlogiken (för relationella databaser görs det direkt i den angivna artikeln).
Klass Avdelning;
namn = DATA STRĂNG[100] (Avdelning);
CLASS Employee;
department = DATA Department (Employee);
chief = DATA Employee (Employee);
name = DATA STRING[100] (Employee);
salary = DATA NUMERIC[14,2] (Employee);
Uppgift 1.1
Lista över anstÀllda som har en lön som Àr högre Àn deras omedelbara chef.
Relational
select a.*
from employee a, employee b
where b.id = a.chief_id
and a.salary > b.salary
Funktionell
VĂLJ namn(AnstĂ€lld a) DĂR lön(a) > lön(styrelse(a));
Uppgift 1.2
Lista över anstÀllda som tjÀnar högst lön i sin avdelning.
Relational
select a.*
from employee a
where a.salary = ( select max(salary) from employee b
where b.department_id = a.department_id )
Funktionell
maxSalary 'Maximal lön' (Department s) =Â
    GRUPPERA MAX lön (AnstÀlld e) OM avdelning(e) = s;
VĂLJ namn (AnstĂ€lld a) DĂR lön(a) = maxSalary(avdelning(a));
// ОлО ДŃлО "Đ·Đ°ĐžĐœĐ»Đ°ĐčĐœĐžŃŃ"
SELECT name(Employee a) WHEREÂ
    salary(a) = maxSalary(GROUP MAX salary(Employee e) IF department(e) = department(a));
BÄda implementationerna Àr ekvivalenta. För det första fallet i en relationell databas kan CREATE VIEW anvÀndas, som pÄ samma sÀtt först berÀknar den maximala lönen för en specifik avdelning. För tydlighetens skull kommer jag i fortsÀttningen att anvÀnda det första fallet, eftersom det bÀttre Äterspeglar lösningen.
Uppgift 1.3
Lista ID för avdelningar dÀr antalet anstÀllda inte överstiger 3 personer.
Relational
select department_id
from employee
group by department_id
having count(*) <= 3
Funktionell
antalAnstĂ€llda 'Antal anstĂ€llda' (Avdelning d) =Â
    GROUP SUM 1 IF department(Employee e) = d;
VĂLJ Avdelning d DĂR antalAnstĂ€llda(d) <= 3;
Uppgift 1.4
Lista över anstÀllda som inte har en utsedd chef som arbetar i samma avdelning.
Relational
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
Funktionell
VĂLJ namn(Employee a) DĂR INTE (avdelning(chief(a)) = avdelning(a));
Uppgift 1.5
Hitta ID för avdelningar med högsta totala löner för anstÀllda.
Relational
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 )
Funktionell
salarySum 'Maximal lön' (Department d) =Â
    GROUP SUM salary(Employee e) IF department(e) = d;
maxSalarySum 'Maximal lön för avdelningar' () =Â
    GRUPP MAX salarySum(Department d);
SELECT Department d WHERE salarySum(d) = maxSalarySum();
Vi gÄr vidare till mer komplexa uppgifter frÄn en annan . Den innehÄller en detaljerad genomgÄng av hur man implementerar denna uppgift i MS SQL.
Uppgift 2.1
Vilka försÀljare sÄlde mer Àn 30 enheter av produkt nr 1 under 1997?
DomÀnlogik (som tidigare i RDBMS hoppa över deklarationen):
CLASS Employee 'SĂ€ljare';
lastName 'Efternamn' = DATA STRING[100] (Employee);
CLASS Product 'Produkt';
id = DATA INTEGER (Product);
name = DATA STRING[100] (Product);
Klass Order 'BestÀllning';
date = DATA DATE (Order);
employee = DATA Employee (Order);
CLASS Detail 'BestÀllningspost';
order = DATA Order (Detail);
product = DATA Product (Detail);
quantity = DATA NUMERIC[10,5] (Detail);
Relational
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
Funktionell
sĂ„ld (AnstĂ€lld e, INTEGER produktId, INTEGER Ă„r) =Â
    GRUPPERA SUMMERA kvantitet(OrderDetail d) IFÂ
        anstĂ€lld(order(d)) = e OCHÂ
        id(produkt(d)) = produktId OCHÂ
        utdragĂ
r(datum(order(d))) = Är;
VĂLJ efternamn(AnstĂ€lld e) DĂR sĂ„ld(e, 1, 1997) > 30;
Uppgift 2.2
För varje kund (förnamn, efternamn) hitta tvÄ produkter (namn) som kunden spenderade mest pengar pÄ under 1997.
Vi utvidgar domÀnlogiken frÄn det föregÄende exemplet:
CLASS Customer 'Kund';
contactName 'Namn' = DATA STRING[100] (Kund);
kund = DATA Kund (Order);
enhetspris = DATA NUMERISK[14,2] (Detalj);
rabatt = DATA NUMERISK[6,2] (Detalj);
Relational
VĂLJ KontaktNamn, ProduktNamn FRĂ
N (
VĂLJ c.KontaktNamn, p.ProduktNamn
, RAD_NUMMER() ĂVER (
PARTITIONERA EFTER c.KontaktNamn
ORDNA EFTER SUM(od.Kvantitet * od.Enhetspris * (1 - od.Rabatt)) DESC
) AS BetygEfterBelopp
FRĂ
N Kunder c
GĂ
MED Order o PĂ
o.KundID = c.KundID
GĂ
MED [Order Detaljer] od PĂ
od.OrderID = o.OrderID
GĂ
MED Produkter p PĂ
p.ProduktID = od.ProduktID
DĂR Ă
R(o.OrderDatum) = 1997
GRUPPERA EFTER c.KontaktNamn, p.ProduktNamn
) t
DĂR BetygEfterBelopp < 3
Funktionell
sum (Detalj d) = kvantitet(d) * enhetspris(d) * (1 - rabatt(d));
köpt 'Köpt' (Kund c, Produkt p, HĂLFTAL y) =Â
    GRUPPERA SUMMA sum(Detalj d) OMÂ
        kund(order(d)) = c OCHÂ
        produkt(d) = p OCHÂ
        extraheraĂ
r(datum(order(d))) = y;
betyg 'Betyg' (Kund c, Produkt p, HĂLFTAL y) =Â
    PARTITION SUM 1 ORDER DESC köpta(c, p, y), p BY c, y;
VĂLJ kontaktNamn(Kund c), namn(Produkt p) DĂR betyg(c, p, 1997) < 3;
Operatorn PARTITION fungerar enligt följande princip: den summerar uttrycket som anges efter SUM (hÀr 1), inom angivna grupper (hÀr Kund och à r, men det kan vara vilket uttryck som helst), sorterar inom grupper enligt uttryck som anges i ORDER (hÀr köpt, och om lika, enligt produktens interna kod).
Uppgift 2.3
Hur mÄnga varor behöver bestÀllas frÄn leverantörer för att uppfylla aktuella bestÀllningar.
Vi utökar Äterigen domÀnlogiken:
CLASS Leverantör 'PĐŸŃŃаĐČŃĐžĐș';
companyName = DATA STRĂNG[100] (Leverantör);
leverantör = DATA Leverantör (Produkt);
lagerEnheter 'Lagerbalans' = DATA NUMERISK[10,3] (Produkt);
bestÀllningsnivÄ 'FörsÀljningsnorm' = DATA NUMERISK[10,3] (Produkt);
Relational
VĂLJ s.Företagsnamn, p.ProduktNamn, SUM(od.Kvantitet) + p.BestĂ€llningsnivĂ„ - p.LagerEnheter som AttBestĂ€lla
FRĂ
N Order o
GĂ
MED [Order Detaljer] od PĂ
o.OrderID = od.OrderID
GĂ
MED Produkter p PĂ
od.ProduktID = p.ProduktID
GĂ
MED Leverantörer s PĂ
p.LevarantörID = s.LevarantörID
DĂR o.LevertDatum Ă€r null
GRUPPERA EFTER s.Företagsnamn, p.ProduktNamn, p.LagerEnheter, p.BestÀllningsnivÄ
HAVING p.LagerEnheter < SUM(od.Kvantitet) + p.BestÀllningsnivÄ
Funktionell
bestĂ€lldMenInteLevererad 'BestĂ€lld, men inte levererad' (Produkt p) =Â
    GRUPP SUM mÀngd(OrderDetail d) IF produkt(d) = p;
attBestÀlla 'Till bestÀllning' (Produkt p) = bestÀlldMenInteLevererad(p) + ombestÀllningsnivÄ(p) - enheterILager(p);
VĂLJ företagsnamn(leverantör(Produkt p)), namn(p), attBestĂ€lla(p) DĂR attBestĂ€lla(p) > 0;
Uppgift med stjÀrna
Och till sist ett exempel personligen frÄn mig. Det finns en logik för sociala nÀtverk. MÀnniskor kan vara vÀnner med varandra och gilla varandra. FrÄn en funktionell databas synvinkel skulle detta se ut pÄ följande sÀtt:
Klass Person;
gillar = DATA BOOLEAN (Person, Person);
vÀnner = DATA BOOLEAN (Person, Person);
Det Àr nödvÀndigt att hitta potentiella kandidater för vÀnskap. Mer formellt mÄste vi hitta alla personer A, B, C som sÄ att A Àr vÀn med B, och B Àr vÀn med C, A gillar C, men A Àr inte vÀn med C.
FrÄn en funktionell databas synvinkel skulle förfrÄgan se ut pÄ följande sÀtt:
VĂLJ Person a, Person b, Person c DĂRÂ
    gillar(a, c) OCH INTE vĂ€nner(a, c) OCHÂ
    vÀnner(a, b) OCH vÀnner(b, c);
LÀsaren uppmanas att sjÀlv lösa denna uppgift med SQL. Det antas att vÀnner Àr mycket fÀrre Àn de som gillar. DÀrför ligger de i separata tabeller. Vid framgÄngsrikt lösande finns det ocksÄ en uppgift med tvÄ stjÀrnor. I den Àr vÀnskap inte symmetrisk. FrÄn en funktionell databas kommer detta att se ut sÄ hÀr:
VĂLJ Person a, Person b, Person c DĂRÂ
    gillar(a, c) OCH INTE vĂ€nner(a, c) OCHÂ
    (vĂ€nner(a, b) ELLER vĂ€nner(b, a)) OCHÂ
    (vÀnner(b, c) ELLER vÀnner(c, b));
Uppd: lösningen pÄ uppgiften med första och andra stjÀrnan av :
VĂLJ
pl.PersonAID
,pf.PersonAID
,pff.PersonAID
FRĂ
N Persons SOM p
--Gilla
GĂ
MED PersonRelationShip SOM pl PĂ
pl.PersonAID = p.PersonID
OCH pl.Relation = 'Gilla'
--VĂ€nner
GĂ
MED PersonRelationShip SOM pf PĂ
pf.PersonAID = p.PersonID
OCH pf.Relation = 'VĂ€n'
--VĂ€nners VĂ€nner
GĂ
MED PersonRelationShip SOM pff PĂ
pff.PersonAID = pf.PersonBID
OCH pff.PersonBID = pl.PersonBID
OCH pff.Relation = 'VĂ€n'
--Inte vÀnner Àn
VĂNSTER GĂ
MED PersonRelationShip SOM pnf PĂ
pnf.PersonAID = p.PersonID
OCH pnf.PersonBID = pff.PersonBID
OCH pnf.Relation = 'VĂ€n'
DĂR pnf.PersonAID ĂR NULL
;MED PersonRelationShipCollapsed SOM (
VĂLJ pl.PersonAID
,pl.PersonBID
,pl.Relation
FRĂ
N #PersonRelationShip SOM pl
FĂRENING
VĂLJ pl.PersonBID SOM PersonAID
,pl.PersonAID SOM PersonBID
,pl.Relation
FRĂ
N #PersonRelationShip SOM pl
)
VĂLJ
pl.PersonAID
,pf.PersonBID
,pff.PersonBID
FRĂ
N #Persons SOM p
--Gilla
GĂ
MED PersonRelationShipCollapsed SOM pl PĂ
pl.PersonAID = p.PersonID
OCH pl.Relation = 'Gilla'
--VĂ€nner
GĂ
MED PersonRelationShipCollapsed SOM pf PĂ
pf.PersonAID = p.PersonID
OCH pf.Relation = 'VĂ€n'
--VĂ€nners VĂ€nner
GĂ
MED PersonRelationShipCollapsed SOM pff PĂ
pff.PersonAID = pf.PersonBID
OCH pff.PersonBID = pl.PersonBID
OCH pff.Relation = 'VĂ€n'
--Inte vÀnner Àn
VĂNSTER GĂ
MED PersonRelationShipCollapsed SOM pnf PĂ
pnf.PersonAID = p.PersonID
OCH pnf.PersonBID = pff.PersonBID
OCH pnf.Relation = 'VĂ€n'
DĂR pnf.[PersonAID] ĂR NULL
Slutsats
Det Àr vÀrt att notera att den angivna syntaxen för sprÄket bara Àr en av flera möjliga implementationer av det beskrivna konceptet. SQL har valts som grund och mÄlet var att göra det sÄ likt som möjligt. SjÀlvklart kan vissa kanske ogilla namnen pÄ nyckelord, ordens versaler och sÄ vidare. Det viktigaste hÀr Àr just sjÀlva konceptet. Om man sÄ vill kan man göra en syntax liknande detta i C++ eller Python.
Den beskrivna databaskonceptet har enligt min Äsikt följande fördelar:
- Enkelhet. Detta Àr en relativt subjektiv indikator som inte Àr uppenbar i enklare fall. Men om man ser pÄ mer komplicerade situationer (till exempel uppgifter med stjÀrnor), sÄ tycker jag att det Àr betydligt enklare att skriva sÄdana förfrÄgningar.
- Kapsling. I vissa exempel har jag deklarerat mellanliggande funktioner (till exempel, sÄld, köpt och sÄ vidare), frÄn vilka följande funktioner byggdes. Detta möjliggör, vid behov, att Àndra logiken i vissa funktioner utan att förÀndra logiken i de som Àr beroende av dem. Till exempel kan man göra sÄ att försÀljning sÄld ansÄgs vara helt andra objekt, medan resten av logiken förblir oförÀndrad. Ja, i RDBMS kan detta implementeras med hjÀlp av CREATE VIEW. Men om man skriver hela logiken pÄ detta sÀtt, kommer den att se rÀtt svÄrlÀst ut.
- Avsaknad av semantisk klyfta. En sÄdan databas arbetar med funktioner och klasser (istÀllet för tabeller och fÀlt). Precis som i klassisk programmering (om man anser att en metod Àr en funktion med den första parametern som klassen den tillhör). DÀrför borde det vara betydligt enklare att "vÀnja sig" vid universella programmeringssprÄk. Dessutom gör detta koncept det möjligt att implementera betydligt mer komplexa funktioner. Till exempel kan man införa operatörer av typen i databasen:
KONSTRIKTION sÄld(Employee e, 1, 2019) > 100 OM namn(e) = 'Petya' MEDDELANDE 'NÄgot Petya sÀljer för mycket av en produkt under 2019.';
- Arv och polymorfism. I en funktionell databas kan flera arv introduceras genom konstruktioner som CLASS ClassP: Class1, Class2 och man kan implementera flera polymorfism. Hur exakt, kanske jag skriver om i kommande artiklar.
Trots att detta bara Àr ett koncept har vi redan en viss implementation i Java, som översÀtter all funktionell logik till relationell logik. Dessutom har den snyggt kopplat logiken för vyer och mycket mer, vilket skapar ett helt . I grunden anvÀnder vi RDBMS (just nu bara PostgreSQL) som en "virtuell maskin". Vid en sÄdan översÀttning uppstÄr ibland problem, eftersom RDBMS:s frÄgeoptimerare inte kÀnner till viss statistik som FSDBMS kÀnner till. I teorin skulle man kunna implementera ett databashanteringssystem som skulle anvÀnda en struktur anpassad speciellt för den funktionella logiken som lagringsutrymme.
KĂ€lla: habr.com
