ਕਾਰਜਸ਼ੀਲ DBMS

ਡੇਟਾਬੇਸ ਦੀ ਦੁਨੀਆ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਰਿਲੇਸ਼ਨਲ ਡੀਬੀਐਮਐਸ ਦੁਆਰਾ ਹਾਵੀ ਰਹੀ ਹੈ, ਜੋ ਕਿ SQL ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਇੰਨਾ ਜ਼ਿਆਦਾ ਕਿ ਉੱਭਰ ਰਹੇ ਰੂਪਾਂ ਨੂੰ NoSQL ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਉਹ ਇਸ ਮਾਰਕੀਟ ਵਿੱਚ ਆਪਣੇ ਲਈ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਥਾਨ ਬਣਾਉਣ ਵਿੱਚ ਕਾਮਯਾਬ ਰਹੇ, ਪਰ ਰਿਲੇਸ਼ਨਲ ਡੀਬੀਐਮਐਸ ਮਰਨ ਵਾਲੇ ਨਹੀਂ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਸਰਗਰਮੀ ਨਾਲ ਵਰਤੇ ਜਾ ਰਹੇ ਹਨ।

ਇਸ ਲੇਖ ਵਿੱਚ ਮੈਂ ਇੱਕ ਕਾਰਜਸ਼ੀਲ ਡੇਟਾਬੇਸ ਦੀ ਧਾਰਨਾ ਦਾ ਵਰਣਨ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ. ਬਿਹਤਰ ਸਮਝ ਲਈ, ਮੈਂ ਇਸਦੀ ਤੁਲਨਾ ਕਲਾਸੀਕਲ ਰਿਲੇਸ਼ਨਲ ਮਾਡਲ ਨਾਲ ਕਰਾਂਗਾ। ਇੰਟਰਨੈੱਟ 'ਤੇ ਪਾਏ ਗਏ ਵੱਖ-ਵੱਖ SQL ਟੈਸਟਾਂ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਉਦਾਹਰਣ ਵਜੋਂ ਵਰਤਿਆ ਜਾਵੇਗਾ।

ਜਾਣ ਪਛਾਣ

ਰਿਲੇਸ਼ਨਲ ਡੇਟਾਬੇਸ ਟੇਬਲ ਅਤੇ ਫੀਲਡਾਂ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ। ਇੱਕ ਫੰਕਸ਼ਨਲ ਡੇਟਾਬੇਸ ਵਿੱਚ, ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨ ਕ੍ਰਮਵਾਰ ਇਸਦੀ ਬਜਾਏ ਵਰਤੇ ਜਾਣਗੇ। N ਕੁੰਜੀਆਂ ਦੇ ਨਾਲ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਇੱਕ ਖੇਤਰ ਨੂੰ N ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਇੱਕ ਫੰਕਸ਼ਨ ਵਜੋਂ ਦਰਸਾਇਆ ਜਾਵੇਗਾ। ਟੇਬਲ ਦੇ ਵਿਚਕਾਰ ਸਬੰਧਾਂ ਦੀ ਬਜਾਏ, ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਵੇਗੀ ਜੋ ਕਲਾਸ ਦੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹਨ ਜਿਸ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਬਣਾਇਆ ਗਿਆ ਹੈ। JOIN ਦੀ ਬਜਾਏ ਫੰਕਸ਼ਨ ਰਚਨਾ ਵਰਤੀ ਜਾਵੇਗੀ।

ਕਾਰਜਾਂ 'ਤੇ ਸਿੱਧੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ, ਮੈਂ ਡੋਮੇਨ ਤਰਕ ਦੇ ਕੰਮ ਦਾ ਵਰਣਨ ਕਰਾਂਗਾ. DDL ਲਈ ਮੈਂ PostgreSQL ਸੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗਾ। ਕਾਰਜਸ਼ੀਲ ਲਈ ਇਸਦਾ ਆਪਣਾ ਸੰਟੈਕਸ ਹੈ।

ਟੇਬਲ ਅਤੇ ਖੇਤਰ

ਨਾਮ ਅਤੇ ਕੀਮਤ ਖੇਤਰਾਂ ਦੇ ਨਾਲ ਇੱਕ ਸਧਾਰਨ Sku ਵਸਤੂ:

ਸੰਬੰਧਤ

CREATE TABLE Sku
(
    id bigint NOT NULL,
    name character varying(100),
    price numeric(10,5),
    CONSTRAINT id_pkey PRIMARY KEY (id)
)

ਕਾਰਜਸ਼ੀਲ

CLASS Sku;
name = DATA STRING[100] (Sku);
price = DATA NUMERIC[10,5] (Sku);


ਅਸੀਂ ਦੋ ਦਾ ਐਲਾਨ ਕਰਦੇ ਹਾਂ ਫੰਕਸ਼ਨ, ਜੋ ਇੱਕ ਪੈਰਾਮੀਟਰ Sku ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਲੈਂਦੇ ਹਨ ਅਤੇ ਇੱਕ ਮੁੱਢਲੀ ਕਿਸਮ ਵਾਪਸ ਕਰਦੇ ਹਨ।

ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਇੱਕ ਫੰਕਸ਼ਨਲ DBMS ਵਿੱਚ ਹਰੇਕ ਵਸਤੂ ਵਿੱਚ ਕੁਝ ਅੰਦਰੂਨੀ ਕੋਡ ਹੋਵੇਗਾ ਜੋ ਆਪਣੇ ਆਪ ਤਿਆਰ ਹੁੰਦਾ ਹੈ ਅਤੇ ਜੇਕਰ ਲੋੜ ਹੋਵੇ ਤਾਂ ਇਸ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਆਉ ਉਤਪਾਦ/ਸਟੋਰ/ਸਪਲਾਇਰ ਲਈ ਕੀਮਤ ਨਿਰਧਾਰਤ ਕਰੀਏ। ਇਹ ਸਮੇਂ ਦੇ ਨਾਲ ਬਦਲ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਆਓ ਸਾਰਣੀ ਵਿੱਚ ਇੱਕ ਸਮਾਂ ਖੇਤਰ ਜੋੜੀਏ। ਮੈਂ ਕੋਡ ਨੂੰ ਛੋਟਾ ਕਰਨ ਲਈ ਇੱਕ ਰਿਲੇਸ਼ਨਲ ਡੇਟਾਬੇਸ ਵਿੱਚ ਡਾਇਰੈਕਟਰੀਆਂ ਲਈ ਟੇਬਲ ਘੋਸ਼ਿਤ ਕਰਨਾ ਛੱਡ ਦੇਵਾਂਗਾ:

ਸੰਬੰਧਤ

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)
)

ਕਾਰਜਸ਼ੀਲ

CLASS Sku;
CLASS Store;
CLASS Supplier;
dateTime = DATA DATETIME (Sku, Store, Supplier);
price = DATA NUMERIC[10,5] (Sku, Store, Supplier);


ਸੂਚੀ-ਪੱਤਰ

ਆਖਰੀ ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਸਾਰੀਆਂ ਕੁੰਜੀਆਂ ਅਤੇ ਮਿਤੀ 'ਤੇ ਇੱਕ ਸੂਚਕਾਂਕ ਬਣਾਵਾਂਗੇ ਤਾਂ ਜੋ ਅਸੀਂ ਇੱਕ ਖਾਸ ਸਮੇਂ ਲਈ ਕੀਮਤ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਲੱਭ ਸਕੀਏ।

ਸੰਬੰਧਤ

CREATE INDEX prices_date
    ON prices
    (skuId, storeId, supplierId, dateTime)

ਕਾਰਜਸ਼ੀਲ

INDEX Sku sk, Store st, Supplier sp, dateTime(sk, st, sp);


ਕੰਮ

ਦੇ ਅਨੁਸਾਰੀ ਤੱਕ ਲਿਆ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਸਮੱਸਿਆ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ ਲੇਖ Habr 'ਤੇ.

ਪਹਿਲਾਂ, ਆਓ ਡੋਮੇਨ ਤਰਕ ਦੀ ਘੋਸ਼ਣਾ ਕਰੀਏ (ਰਿਲੇਸ਼ਨਲ ਡੇਟਾਬੇਸ ਲਈ ਇਹ ਉਪਰੋਕਤ ਲੇਖ ਵਿੱਚ ਸਿੱਧਾ ਕੀਤਾ ਗਿਆ ਹੈ)।

CLASS Department;
name = DATA STRING[100] (Department);

CLASS Employee;
department = DATA Department (Employee);
chief = DATA Employee (Employee);
name = DATA STRING[100] (Employee);
salary = DATA NUMERIC[14,2] (Employee);


ਟਾਸਕ 1.1

ਉਹਨਾਂ ਕਰਮਚਾਰੀਆਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ ਜੋ ਆਪਣੇ ਤਤਕਾਲ ਸੁਪਰਵਾਈਜ਼ਰ ਤੋਂ ਵੱਧ ਤਨਖਾਹ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ।

ਸੰਬੰਧਤ

select a.*
from   employee a, employee b
where  b.id = a.chief_id
and    a.salary > b.salary

ਕਾਰਜਸ਼ੀਲ

SELECT name(Employee a) WHERE salary(a) > salary(chief(a));


ਟਾਸਕ 1.2

ਉਨ੍ਹਾਂ ਕਰਮਚਾਰੀਆਂ ਦੀ ਸੂਚੀ ਬਣਾਓ ਜੋ ਆਪਣੇ ਵਿਭਾਗ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਤਨਖਾਹ ਲੈਂਦੇ ਹਨ

ਸੰਬੰਧਤ

select a.*
from   employee a
where  a.salary = ( select max(salary) from employee b
                    where  b.department_id = a.department_id )

ਕਾਰਜਸ਼ੀਲ

maxSalary 'Максимальная зарплата' (Department s) = 
    GROUP MAX salary(Employee e) IF department(e) = s;
SELECT name(Employee a) WHERE salary(a) = maxSalary(department(a));

// или если "заинлайнить"
SELECT name(Employee a) WHERE 
    salary(a) = maxSalary(GROUP MAX salary(Employee e) IF department(e) = department(a));


ਦੋਵੇਂ ਲਾਗੂਕਰਨ ਬਰਾਬਰ ਹਨ। ਪਹਿਲੇ ਕੇਸ ਲਈ, ਇੱਕ ਰਿਲੇਸ਼ਨਲ ਡੇਟਾਬੇਸ ਵਿੱਚ ਤੁਸੀਂ CREATE VIEW ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਉਸੇ ਤਰ੍ਹਾਂ ਪਹਿਲਾਂ ਇਸ ਵਿੱਚ ਕਿਸੇ ਖਾਸ ਵਿਭਾਗ ਲਈ ਵੱਧ ਤੋਂ ਵੱਧ ਤਨਖਾਹ ਦੀ ਗਣਨਾ ਕਰੇਗਾ। ਇਸ ਤੋਂ ਬਾਅਦ, ਸਪਸ਼ਟਤਾ ਲਈ, ਮੈਂ ਪਹਿਲੇ ਕੇਸ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗਾ, ਕਿਉਂਕਿ ਇਹ ਹੱਲ ਨੂੰ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਦਰਸਾਉਂਦਾ ਹੈ।

ਟਾਸਕ 1.3

ਵਿਭਾਗ ਆਈਡੀ ਦੀ ਇੱਕ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ, ਕਰਮਚਾਰੀਆਂ ਦੀ ਗਿਣਤੀ ਜਿਸ ਵਿੱਚ 3 ਲੋਕਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ।

ਸੰਬੰਧਤ

select department_id
from   employee
group  by department_id
having count(*) <= 3

ਕਾਰਜਸ਼ੀਲ

countEmployees 'Количество сотрудников' (Department d) = 
    GROUP SUM 1 IF department(Employee e) = d;
SELECT Department d WHERE countEmployees(d) <= 3;


ਟਾਸਕ 1.4

ਉਹਨਾਂ ਕਰਮਚਾਰੀਆਂ ਦੀ ਸੂਚੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੋ ਜਿਨ੍ਹਾਂ ਕੋਲ ਉਸੇ ਵਿਭਾਗ ਵਿੱਚ ਕੰਮ ਕਰਨ ਵਾਲਾ ਕੋਈ ਮਨੋਨੀਤ ਮੈਨੇਜਰ ਨਹੀਂ ਹੈ।

ਸੰਬੰਧਤ

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

ਕਾਰਜਸ਼ੀਲ

SELECT name(Employee a) WHERE NOT (department(chief(a)) = department(a));


ਟਾਸਕ 1.5

ਅਧਿਕਤਮ ਕੁੱਲ ਕਰਮਚਾਰੀ ਤਨਖਾਹ ਦੇ ਨਾਲ ਵਿਭਾਗ IDs ਦੀ ਇੱਕ ਸੂਚੀ ਲੱਭੋ.

ਸੰਬੰਧਤ

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 )

ਕਾਰਜਸ਼ੀਲ

salarySum 'Максимальная зарплата' (Department d) = 
    GROUP SUM salary(Employee e) IF department(e) = d;
maxSalarySum 'Максимальная зарплата отделов' () = 
    GROUP MAX salarySum(Department d);
SELECT Department d WHERE salarySum(d) = maxSalarySum();


ਆਉ ਦੂਜੇ ਤੋਂ ਹੋਰ ਗੁੰਝਲਦਾਰ ਕੰਮਾਂ ਵੱਲ ਵਧੀਏ ਲੇਖ. ਇਸ ਵਿੱਚ MS SQL ਵਿੱਚ ਇਸ ਕਾਰਜ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ ਦਾ ਵਿਸਤ੍ਰਿਤ ਵਿਸ਼ਲੇਸ਼ਣ ਹੈ।

ਟਾਸਕ 2.1

ਕਿਹੜੇ ਵਿਕਰੇਤਾਵਾਂ ਨੇ 1997 ਵਿੱਚ ਉਤਪਾਦ ਨੰਬਰ 30 ਦੇ 1 ਤੋਂ ਵੱਧ ਯੂਨਿਟ ਵੇਚੇ ਸਨ?

ਡੋਮੇਨ ਤਰਕ (ਆਰਡੀਬੀਐਮਐਸ 'ਤੇ ਪਹਿਲਾਂ ਵਾਂਗ ਅਸੀਂ ਘੋਸ਼ਣਾ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹਾਂ):

CLASS Employee 'Продавец';
lastName 'Фамилия' = DATA STRING[100] (Employee);

CLASS Product 'Продукт';
id = DATA INTEGER (Product);
name = DATA STRING[100] (Product);

CLASS Order 'Заказ';
date = DATA DATE (Order);
employee = DATA Employee (Order);

CLASS Detail 'Строка заказа';

order = DATA Order (Detail);
product = DATA Product (Detail);
quantity = DATA NUMERIC[10,5] (Detail);


ਸੰਬੰਧਤ

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

ਕਾਰਜਸ਼ੀਲ

sold (Employee e, INTEGER productId, INTEGER year) = 
    GROUP SUM quantity(OrderDetail d) IF 
        employee(order(d)) = e AND 
        id(product(d)) = productId AND 
        extractYear(date(order(d))) = year;
SELECT lastName(Employee e) WHERE sold(e, 1, 1997) > 30;


ਟਾਸਕ 2.2

ਹਰੇਕ ਖਰੀਦਦਾਰ (ਨਾਮ, ਉਪਨਾਮ) ਲਈ, ਉਹ ਦੋ ਵਸਤੂਆਂ (ਨਾਮ) ਲੱਭੋ ਜਿਨ੍ਹਾਂ 'ਤੇ ਖਰੀਦਦਾਰ ਨੇ 1997 ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਪੈਸਾ ਖਰਚ ਕੀਤਾ ਸੀ।

ਅਸੀਂ ਪਿਛਲੀ ਉਦਾਹਰਨ ਤੋਂ ਡੋਮੇਨ ਤਰਕ ਨੂੰ ਵਧਾਉਂਦੇ ਹਾਂ:

CLASS Customer 'Клиент';
contactName 'ФИО' = DATA STRING[100] (Customer);

customer = DATA Customer (Order);

unitPrice = DATA NUMERIC[14,2] (Detail);
discount = DATA NUMERIC[6,2] (Detail);


ਸੰਬੰਧਤ

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

ਕਾਰਜਸ਼ੀਲ

sum (Detail d) = quantity(d) * unitPrice(d) * (1 - discount(d));
bought 'Купил' (Customer c, Product p, INTEGER y) = 
    GROUP SUM sum(Detail d) IF 
        customer(order(d)) = c AND 
        product(d) = p AND 
        extractYear(date(order(d))) = y;
rating 'Рейтинг' (Customer c, Product p, INTEGER y) = 
    PARTITION SUM 1 ORDER DESC bought(c, p, y), p BY c, y;
SELECT contactName(Customer c), name(Product p) WHERE rating(c, p, 1997) < 3;


PARTITION ਆਪਰੇਟਰ ਹੇਠਾਂ ਦਿੱਤੇ ਸਿਧਾਂਤ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ: ਇਹ SUM (ਇੱਥੇ 1) ਤੋਂ ਬਾਅਦ ਨਿਰਦਿਸ਼ਟ ਸਮੀਕਰਨ ਨੂੰ ਜੋੜਦਾ ਹੈ, ਨਿਸ਼ਚਿਤ ਸਮੂਹਾਂ ਦੇ ਅੰਦਰ (ਇੱਥੇ ਗਾਹਕ ਅਤੇ ਸਾਲ, ਪਰ ਕੋਈ ਵੀ ਸਮੀਕਰਨ ਹੋ ਸਕਦਾ ਹੈ), ORDER ਵਿੱਚ ਦਰਸਾਏ ਸਮੀਕਰਨਾਂ ਦੁਆਰਾ ਸਮੂਹਾਂ ਦੇ ਅੰਦਰ ਛਾਂਟੀ ਕਰਦਾ ਹੈ ( ਇੱਥੇ ਖਰੀਦਿਆ, ਅਤੇ ਜੇਕਰ ਬਰਾਬਰ ਹੈ, ਤਾਂ ਅੰਦਰੂਨੀ ਉਤਪਾਦ ਕੋਡ ਦੇ ਅਨੁਸਾਰ)।

ਟਾਸਕ 2.3

ਮੌਜੂਦਾ ਆਰਡਰਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਸਪਲਾਇਰਾਂ ਤੋਂ ਕਿੰਨੇ ਸਾਮਾਨ ਮੰਗਵਾਉਣ ਦੀ ਲੋੜ ਹੈ।

ਆਓ ਡੋਮੇਨ ਤਰਕ ਨੂੰ ਦੁਬਾਰਾ ਵਿਸਤਾਰ ਕਰੀਏ:

CLASS Supplier 'Поставщик';
companyName = DATA STRING[100] (Supplier);

supplier = DATA Supplier (Product);

unitsInStock 'Остаток на складе' = DATA NUMERIC[10,3] (Product);
reorderLevel 'Норма продажи' = DATA NUMERIC[10,3] (Product);


ਸੰਬੰਧਤ

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

ਕਾਰਜਸ਼ੀਲ

orderedNotShipped 'Заказано, но не отгружено' (Product p) = 
    GROUP SUM quantity(OrderDetail d) IF product(d) = p;
toOrder 'К заказу' (Product p) = orderedNotShipped(p) + reorderLevel(p) - unitsInStock(p);
SELECT companyName(supplier(Product p)), name(p), toOrder(p) WHERE toOrder(p) > 0;


ਇੱਕ ਤਾਰੇ ਨਾਲ ਸਮੱਸਿਆ

ਅਤੇ ਆਖਰੀ ਉਦਾਹਰਣ ਮੇਰੇ ਵੱਲੋਂ ਨਿੱਜੀ ਤੌਰ 'ਤੇ ਹੈ। ਇੱਕ ਸੋਸ਼ਲ ਨੈੱਟਵਰਕ ਦਾ ਤਰਕ ਹੈ. ਲੋਕ ਇੱਕ ਦੂਜੇ ਦੇ ਦੋਸਤ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ ਇੱਕ ਦੂਜੇ ਨੂੰ ਪਸੰਦ ਕਰ ਸਕਦੇ ਹਨ। ਇੱਕ ਕਾਰਜਸ਼ੀਲ ਡੇਟਾਬੇਸ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

CLASS Person;
likes = DATA BOOLEAN (Person, Person);
friends = DATA BOOLEAN (Person, Person);


ਦੋਸਤੀ ਲਈ ਸੰਭਾਵਿਤ ਉਮੀਦਵਾਰਾਂ ਨੂੰ ਲੱਭਣਾ ਜ਼ਰੂਰੀ ਹੈ. ਵਧੇਰੇ ਰਸਮੀ ਤੌਰ 'ਤੇ, ਤੁਹਾਨੂੰ ਸਾਰੇ ਲੋਕਾਂ ਨੂੰ A, B, C ਲੱਭਣ ਦੀ ਲੋੜ ਹੈ ਜਿਵੇਂ ਕਿ A B ਦਾ ਦੋਸਤ ਹੈ, ਅਤੇ B C ਨਾਲ ਦੋਸਤ ਹੈ, A ਨੂੰ C ਪਸੰਦ ਹੈ, ਪਰ A C ਨਾਲ ਦੋਸਤ ਨਹੀਂ ਹੈ।
ਇੱਕ ਫੰਕਸ਼ਨਲ ਡਾਟਾਬੇਸ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਪੁੱਛਗਿੱਛ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗੀ:

SELECT Person a, Person b, Person c WHERE 
    likes(a, c) AND NOT friends(a, c) AND 
    friends(a, b) AND friends(b, c);


ਪਾਠਕ ਨੂੰ ਇਸ ਸਮੱਸਿਆ ਨੂੰ SQL ਵਿੱਚ ਆਪਣੇ ਆਪ ਹੱਲ ਕਰਨ ਲਈ ਉਤਸ਼ਾਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਪਸੰਦੀਦਾ ਲੋਕਾਂ ਨਾਲੋਂ ਬਹੁਤ ਘੱਟ ਦੋਸਤ ਹਨ। ਇਸ ਲਈ ਉਹ ਵੱਖਰੇ ਟੇਬਲ ਵਿੱਚ ਹਨ. ਜੇ ਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਦੋ ਸਿਤਾਰਿਆਂ ਵਾਲਾ ਕੰਮ ਵੀ ਹੈ. ਇਸ ਵਿੱਚ, ਦੋਸਤੀ ਸਮਰੂਪ ਨਹੀਂ ਹੈ. ਇੱਕ ਫੰਕਸ਼ਨਲ ਡੇਟਾਬੇਸ 'ਤੇ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

SELECT Person a, Person b, Person c WHERE 
    likes(a, c) AND NOT friends(a, c) AND 
    (friends(a, b) OR friends(b, a)) AND 
    (friends(b, c) OR friends(c, b));


UPD: ਤੋਂ ਪਹਿਲੇ ਅਤੇ ਦੂਜੇ ਤਾਰੇ ਨਾਲ ਸਮੱਸਿਆ ਦਾ ਹੱਲ dss_ਕਾਲਿਕਾ:

SELECT 
   pl.PersonAID
  ,pf.PersonAID
  ,pff.PersonAID
FROM Persons                 AS p
--Лайки                      
JOIN PersonRelationShip      AS pl ON pl.PersonAID = p.PersonID
                                  AND pl.Relation  = 'Like'
--Друзья                     
JOIN PersonRelationShip      AS pf ON pf.PersonAID = p.PersonID 
                                  AND pf.Relation = 'Friend'
--Друзья Друзей              
JOIN PersonRelationShip      AS pff ON pff.PersonAID = pf.PersonBID
                                   AND pff.PersonBID = pl.PersonBID
                                   AND pff.Relation = 'Friend'
--Ещё не дружат         
LEFT JOIN PersonRelationShip AS pnf ON pnf.PersonAID = p.PersonID
                                   AND pnf.PersonBID = pff.PersonBID
                                   AND pnf.Relation = 'Friend'
WHERE pnf.PersonAID IS NULL 

;WITH PersonRelationShipCollapsed AS (
  SELECT pl.PersonAID
        ,pl.PersonBID
        ,pl.Relation 
  FROM #PersonRelationShip      AS pl 
  
  UNION 

  SELECT pl.PersonBID AS PersonAID
        ,pl.PersonAID AS PersonBID
        ,pl.Relation
  FROM #PersonRelationShip      AS pl 
)
SELECT 
   pl.PersonAID
  ,pf.PersonBID
  ,pff.PersonBID
FROM #Persons                      AS p
--Лайки                      
JOIN PersonRelationShipCollapsed  AS pl ON pl.PersonAID = p.PersonID
                                 AND pl.Relation  = 'Like'                                  
--Друзья                          
JOIN PersonRelationShipCollapsed  AS pf ON pf.PersonAID = p.PersonID 
                                 AND pf.Relation = 'Friend'
--Друзья Друзей                   
JOIN PersonRelationShipCollapsed  AS pff ON pff.PersonAID = pf.PersonBID
                                 AND pff.PersonBID = pl.PersonBID
                                 AND pff.Relation = 'Friend'
--Ещё не дружат                   
LEFT JOIN PersonRelationShipCollapsed AS pnf ON pnf.PersonAID = p.PersonID
                                   AND pnf.PersonBID = pff.PersonBID
                                   AND pnf.Relation = 'Friend'
WHERE pnf.[PersonAID] IS NULL 

ਸਿੱਟਾ

ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਦਿੱਤੀ ਗਈ ਭਾਸ਼ਾ ਸੰਟੈਕਸ ਦਿੱਤੇ ਗਏ ਸੰਕਲਪ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਵਿਕਲਪਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। SQL ਨੂੰ ਆਧਾਰ ਵਜੋਂ ਲਿਆ ਗਿਆ ਸੀ, ਅਤੇ ਟੀਚਾ ਸੀ ਕਿ ਇਸ ਨੂੰ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਸਮਾਨ ਬਣਾਇਆ ਜਾਵੇ। ਬੇਸ਼ੱਕ, ਕੁਝ ਨੂੰ ਕੀਵਰਡਸ, ਵਰਡ ਰਜਿਸਟਰ, ਆਦਿ ਦੇ ਨਾਮ ਪਸੰਦ ਨਹੀਂ ਹੋ ਸਕਦੇ ਹਨ। ਇੱਥੇ ਮੁੱਖ ਗੱਲ ਇਹ ਸੰਕਲਪ ਹੈ. ਜੇਕਰ ਲੋੜ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ C++ ਅਤੇ Python ਦੋਵੇਂ ਸਮਾਨ ਸੰਟੈਕਸ ਬਣਾ ਸਕਦੇ ਹੋ।

ਵਰਣਿਤ ਡੇਟਾਬੇਸ ਸੰਕਲਪ, ਮੇਰੀ ਰਾਏ ਵਿੱਚ, ਹੇਠਾਂ ਦਿੱਤੇ ਫਾਇਦੇ ਹਨ:

• ਸੌਖਾ. ਇਹ ਇੱਕ ਮੁਕਾਬਲਤਨ ਵਿਅਕਤੀਗਤ ਸੂਚਕ ਹੈ ਜੋ ਸਧਾਰਨ ਮਾਮਲਿਆਂ ਵਿੱਚ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੁੰਦਾ। ਪਰ ਜੇ ਤੁਸੀਂ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਕੇਸਾਂ ਨੂੰ ਦੇਖਦੇ ਹੋ (ਉਦਾਹਰਣ ਵਜੋਂ, ਤਾਰਿਆਂ ਨਾਲ ਸਮੱਸਿਆਵਾਂ), ਤਾਂ, ਮੇਰੀ ਰਾਏ ਵਿੱਚ, ਅਜਿਹੇ ਸਵਾਲਾਂ ਨੂੰ ਲਿਖਣਾ ਬਹੁਤ ਸੌਖਾ ਹੈ.
• ਇਨਕੈਪਸੂਲੇਸ਼ਨ. ਕੁਝ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਮੈਂ ਇੰਟਰਮੀਡੀਏਟ ਫੰਕਸ਼ਨ ਘੋਸ਼ਿਤ ਕੀਤਾ (ਉਦਾਹਰਨ ਲਈ, ਵੇਚਿਆ, ਖਰੀਦੀ ਆਦਿ), ਜਿਸ ਤੋਂ ਬਾਅਦ ਦੇ ਫੰਕਸ਼ਨ ਬਣਾਏ ਗਏ ਸਨ। ਇਹ ਤੁਹਾਨੂੰ ਕੁਝ ਫੰਕਸ਼ਨਾਂ ਦੇ ਤਰਕ ਨੂੰ ਬਦਲਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜੇ ਲੋੜ ਹੋਵੇ, ਉਹਨਾਂ ਦੇ ਤਰਕ ਨੂੰ ਬਦਲੇ ਬਿਨਾਂ ਜੋ ਉਹਨਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਵਿਕਰੀ ਕਰ ਸਕਦੇ ਹੋ ਵੇਚਿਆ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵੱਖਰੀਆਂ ਵਸਤੂਆਂ ਤੋਂ ਗਿਣਿਆ ਗਿਆ ਸੀ, ਜਦੋਂ ਕਿ ਬਾਕੀ ਤਰਕ ਨਹੀਂ ਬਦਲੇਗਾ। ਹਾਂ, ਇਸਨੂੰ CREATE VIEW ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ RDBMS ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਪਰ ਜੇ ਸਾਰਾ ਤਰਕ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖਿਆ ਜਾਵੇ ਤਾਂ ਇਹ ਬਹੁਤਾ ਪੜ੍ਹਨਯੋਗ ਨਹੀਂ ਲੱਗੇਗਾ।
• ਕੋਈ ਅਰਥਗਤ ਅੰਤਰ ਨਹੀਂ. ਅਜਿਹਾ ਡੇਟਾਬੇਸ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਕਲਾਸਾਂ (ਟੇਬਲ ਅਤੇ ਫੀਲਡਾਂ ਦੀ ਬਜਾਏ) 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ। ਜਿਵੇਂ ਕਿ ਕਲਾਸੀਕਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ (ਜੇਕਰ ਅਸੀਂ ਇਹ ਮੰਨ ਲਈਏ ਕਿ ਇੱਕ ਵਿਧੀ ਕਲਾਸ ਦੇ ਰੂਪ ਵਿੱਚ ਪਹਿਲੇ ਪੈਰਾਮੀਟਰ ਵਾਲਾ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜਿਸ ਨਾਲ ਇਹ ਸੰਬੰਧਿਤ ਹੈ)। ਇਸ ਅਨੁਸਾਰ, ਯੂਨੀਵਰਸਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨਾਲ "ਦੋਸਤ ਬਣਾਉਣਾ" ਬਹੁਤ ਸੌਖਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਸੰਕਲਪ ਬਹੁਤ ਜ਼ਿਆਦਾ ਗੁੰਝਲਦਾਰ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਆਪਰੇਟਰਾਂ ਨੂੰ ਏਮਬੇਡ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ:

  CONSTRAINT sold(Employee e, 1, 2019) > 100 IF name(e) = 'Петя' MESSAGE  'Что-то Петя продает слишком много одного товара в 2019 году';


• ਵਿਰਾਸਤ ਅਤੇ ਪੋਲੀਮੋਰਫਿਜ਼ਮ. ਇੱਕ ਫੰਕਸ਼ਨਲ ਡੇਟਾਬੇਸ ਵਿੱਚ, ਤੁਸੀਂ CLASS ClassP ਦੁਆਰਾ ਮਲਟੀਪਲ ਵਿਰਾਸਤ ਨੂੰ ਪੇਸ਼ ਕਰ ਸਕਦੇ ਹੋ: Class1, Class2 ਮਲਟੀਪਲ ਪੋਲੀਮੋਰਫਿਜ਼ਮ ਬਣਾਉਂਦੇ ਅਤੇ ਲਾਗੂ ਕਰਦੇ ਹਨ। ਮੈਂ ਸ਼ਾਇਦ ਭਵਿੱਖ ਦੇ ਲੇਖਾਂ ਵਿੱਚ ਬਿਲਕੁਲ ਕਿਵੇਂ ਲਿਖਾਂਗਾ.

ਭਾਵੇਂ ਇਹ ਕੇਵਲ ਇੱਕ ਧਾਰਨਾ ਹੈ, ਸਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ Java ਵਿੱਚ ਕੁਝ ਲਾਗੂਕਰਨ ਹੈ ਜੋ ਸਾਰੇ ਕਾਰਜਸ਼ੀਲ ਤਰਕ ਨੂੰ ਰਿਲੇਸ਼ਨਲ ਤਰਕ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ। ਨਾਲ ਹੀ, ਪ੍ਰਤੀਨਿਧਤਾਵਾਂ ਦਾ ਤਰਕ ਅਤੇ ਹੋਰ ਬਹੁਤ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ ਇਸ ਨਾਲ ਸੁੰਦਰਤਾ ਨਾਲ ਜੁੜੀਆਂ ਹੋਈਆਂ ਹਨ, ਜਿਸਦਾ ਧੰਨਵਾਦ ਸਾਨੂੰ ਪੂਰਾ ਮਿਲਦਾ ਹੈ ਪਲੇਟਫਾਰਮ. ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ, ਅਸੀਂ RDBMS (ਹੁਣ ਲਈ ਸਿਰਫ਼ PostgreSQL) ਨੂੰ "ਵਰਚੁਅਲ ਮਸ਼ੀਨ" ਵਜੋਂ ਵਰਤਦੇ ਹਾਂ। ਇਸ ਅਨੁਵਾਦ ਨਾਲ ਕਈ ਵਾਰ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ ਕਿਉਂਕਿ RDBMS ਕਿਊਰੀ ਆਪਟੀਮਾਈਜ਼ਰ ਕੁਝ ਅੰਕੜੇ ਨਹੀਂ ਜਾਣਦਾ ਹੈ ਜੋ FDBMS ਜਾਣਦਾ ਹੈ। ਸਿਧਾਂਤ ਵਿੱਚ, ਇੱਕ ਡੇਟਾਬੇਸ ਪ੍ਰਬੰਧਨ ਪ੍ਰਣਾਲੀ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਸੰਭਵ ਹੈ ਜੋ ਇੱਕ ਖਾਸ ਢਾਂਚੇ ਨੂੰ ਸਟੋਰੇਜ ਦੇ ਤੌਰ ਤੇ ਵਰਤੇਗਾ, ਖਾਸ ਤੌਰ 'ਤੇ ਕਾਰਜਸ਼ੀਲ ਤਰਕ ਲਈ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

ਸਰੋਤ: www.habr.com