แแแแแชแแแแ แแแแแแแก แกแแแงแแ แแจแ แแแแ แฎแแแแ แแแแแแแ แแแก แ แแแแชแแฃแ แ DBMS-แแแ, แ แแแแแแแช แแงแแแแแแ SQL แแแแก. แแแแแแแ, แ แแ แแแแแแแแ แแแฃแ แแแ แแแแขแแแก NoSQL แแฌแแแแแ. แแแ แแแแฎแแ แฎแแก แแ แแแแแ แแ แกแแแฃแแแ แ แแแแแกแแแแก แแแ แแแแฃแแ แแแแแแแก แแแแแงแแคแ, แแแแ แแ แ แแแแชแแฃแ แ DBMS แแ แแแแแแแแ แแ แแแ แซแแแแแก แแฅแขแแฃแ แแ แแแแแงแแแแแแก แแแแ แแแแแแแแกแแแแก.
แแ แกแขแแขแแแจแ แแแแแ แแฆแแฌแแ แ แคแฃแแฅแชแแฃแ แ แแแแแชแแแแ แแแแแก แแแแชแแคแชแแ. แฃแแแ แแแกแแแแแแ, แแแแก แแแแแแแแแ แแแแกแแแฃแ แ แแแแชแแฃแ แแแแแแแแ แจแแแแ แแแแ. แแแแแแแแแแแ แแแแแงแแแแแฃแแ แแฅแแแแ แแแขแแ แแแขแจแ แแแแแแแ แกแฎแแแแแกแฎแแ 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);
แแแแชแแแแแ
แแแแแฌแงแแ แจแแกแแแแแแกแแแแ แแฆแแแฃแแ แจแแแแ แแแแ แแแ แขแแแ แแ แแแแแแแแแ
แแแ แแแแ, แแแแแ แแแแแแแชแฎแแแแ แแแแแแแก แแแแแแ (แ แแแแชแแฃแ แ แแแแแชแแแแ แแแแแกแแแแก แแก แแแแแแแ แฃแจแฃแแแแ แแแแแ แแแชแแแฃแ แกแขแแขแแแจแ).
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
แแแแแแ แแแแงแแคแแแแแแก แแแ แแแแแแก แแแฌแแแแแแแก แกแแ แแแแแแจแ แแแแแแแก แแแฅแกแแแแแฃแ แ แฏแแแฃแ แ แฎแแแคแแกแแ.
แ แแแแขแแฃแ แ
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();
แแแแแ แแแแแแแแแ แกแฎแแแแแ แฃแคแ แ แ แแฃแ แแแแชแแแแแแ
แแแแแแแแ 2.1
แ แแแแแแ แแแแงแแแแแแแแแ แแแงแแแแก 1997 แแ แแแฃแแแ แแแขแ No30 แแ แแแฃแฅแขแ 1 แฌแแแก?
แแแแแแแก แแแแแแ (แ แแแแ แช แแแ แ RDBMS-แแ, แฉแแแ แแแแแแขแแแแแ แแแแแแ แแชแแแก):
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: แแ แแแแแแแก แแแแแฌแงแแแขแ แแแ แแแแ แแ แแแแ แ แแแ แกแแแแแแแ
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-แแก แแกแแแแกแ แกแแแขแแฅแกแ.
แแฆแฌแแ แแแ แแแแแชแแแแ แแแแแก แแแแชแแคแชแแแก, แฉแแแ แแแ แแ, แแฅแแก แจแแแแแแ แฃแแแ แแขแแกแแแแแ:
- แแแแแฃแฎแขแแแก. แแก แจแแแแ แแแแ แกแฃแแแแฅแขแฃแ แ แแแฉแแแแแแแแแ, แ แแแแแแช แแ แฉแแแก แแแ แขแแ แจแแแแฎแแแแแแจแ. แแแแ แแ แแฃ แแแแแฎแแแแแ แฃแคแ แ แ แแฃแ แจแแแแฎแแแแแแก (แแแแแแแแแ, แแแ แกแแแแแแแแแแ แแแแแแจแแ แแแฃแแ แแ แแแแแแแแ), แแแจแแ, แฉแแแ แแแ แแ, แแกแแแ แแแแฎแแแแแแแก แแแฌแแ แ แแแแ แแ แฃแคแ แ แแแแแแแ.
- ะะฝะบะฐะฟััะปััะธั. แแแแแแ แ แแแแแแแแจแ แแ แแแแแแแชแฎแแแ แจแฃแแแแแฃแ แ แคแฃแแฅแชแแแแ (แแแแแแแแแ, แแแแงแแแ, แจแแแซแแแ แแ แ.แจ.), แกแแแแแแแช แแจแแแแ แจแแแแแแแ แคแฃแแฅแชแแแแ. แแก แกแแจแฃแแแแแแก แแแซแแแแ แจแแชแแแแแ แแแ แแแแฃแแ แคแฃแแฅแชแแแแแก แแแแแแ, แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แแแแแ แแแแแแแแแแฃแแ แแแแแแแก แจแแชแแแแก แแแ แแจแ. แแแแแแแแแ, แจแแแแซแแแแ แแแแแแแแ แแแงแแแแแแ แแแแงแแแ แแแแแแแแ แแงแ แกแ แฃแแแแ แแแแกแฎแแแแแแฃแแ แแแแแฅแขแแแแแแ, แฎแแแ แแแแแ แฉแแแ แแแแแแ แแ แจแแแชแแแแแ. แแแแฎ, แแก แจแแแซแแแแ แแแแฎแแ แชแแแแแแก RDBMS-แจแ CREATE VIEW-แแก แแแแแงแแแแแแ. แแแแ แแ แแฃ แแแแแ แแแแแแ แแกแแ แแแฌแแ แแแ, แแก แแ แช แแกแ แฌแแกแแแแแฎแแ แแแแแแงแฃแ แแแ.
- แแ แแแแแ แ แกแแแแแขแแแฃแ แ แฎแแ แแแแ. แแกแแแ แแแแแชแแแแ แแแแ แแฃแจแแแแก แคแฃแแฅแชแแแแกแ แแ แแแแกแแแแ (แชแฎแ แแแแแแกแ แแ แแแแแแแก แแแชแแแแ). แแกแแแ, แ แแแแ แช แแแแกแแแฃแ แแ แแแ แแแแ แแแแจแ (แแฃ แฉแแแแแแแ, แ แแ แแแแแแ แแ แแก แคแฃแแฅแชแแ แแแ แแแแ แแแ แแแแขแ แแ แแ แแแแกแแก แกแแฎแแ, แ แแแแแกแแช แแแฃแแแแแก). แจแแกแแแแแแกแแ, แแแแ แแ แฃแคแ แ แแแแแแ แฃแแแ แแงแแก แฃแแแแแ แกแแแฃแ แ แแ แแแ แแแแ แแแแก แแแแแแแ โแแแแแแแแ แแแโ. แแแ แแ แแแแกแ, แแก แแแแชแแคแชแแ แแซแแแแ แแแแ แแ แฃแคแ แ แ แแฃแแ แคแฃแแฅแชแแแแแ แแแแก แแแแฎแแ แชแแแแแแแก แกแแจแฃแแแแแแก. แแแแแแแแแ, แจแแแแซแแแแ แฉแแ แแแ แแแแ แแขแแ แแแ, แ แแแแ แแชแแ:
CONSTRAINT sold(Employee e, 1, 2019) > 100 IF name(e) = 'ะะตัั' MESSAGE 'ะงัะพ-ัะพ ะะตัั ะฟัะพะดะฐะตั ัะปะธัะบะพะผ ะผะฝะพะณะพ ะพะดะฝะพะณะพ ัะพะฒะฐัะฐ ะฒ 2019 ะณะพะดั';
- แแแแแแแแ แแแแ แแ แแแแแแแ แคแแแแ. แคแฃแแฅแชแแแแแแฃแ แแแแแชแแแแ แแแแแจแ แจแแแแซแแแแ แแแแแ แแแ แแ แแแแแฏแแ แแแ แแแแแแแแ แแแแ CLASS ClassP-แแก แแแจแแแแแแ: Class1, Class2 แแแแกแขแ แฃแฅแชแแแแ แแ แแแแแฎแแ แชแแแแแ แแ แแแแแฏแแ แแแ แแแแแแแ แคแแแแ. แแฃแกแขแแ แ แแแแ แแแแฌแแ แแแแแ แแแแแแแ แกแขแแขแแแแจแ.
แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแก แแฎแแแแ แแแแชแแคแชแแแ, แฉแแแ แฃแแแ แแแแฅแแก แแแ แแแแฃแแ แแแแแแแแแขแแชแแ Java-แจแ, แ แแแแแแช แแแ แแแแแก แแแแ แคแฃแแฅแชแแฃแ แแแแแแแก แ แแแแชแแฃแ แแแแแแแจแ. แแแ แแ แแแแกแ, แแแกแแ แแแแแแแ แแ แแก แแแแแแ แแแฃแแ แฌแแ แแแแแแแแก แแแแแแ แแ แแแแ แ แกแฎแแ แ แแ, แ แแกแ แฌแงแแแแแแแแช แแแฆแแแ แแแแแแแแแแก
แฌแงแแ แ: www.habr.com