Funktionell DBMS

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 artiklar 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 artiklar. 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 dss_kalika:

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 plattformen. 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

Köp pĂ„litlig webbhotell med DDoS-skydd, VPS VDS-servrar đŸ”„ Köp pĂ„litlig webbhotell med DDoS-skydd, VPS VDS-servrar | ProHoster