3

在我的期末考试中，我得到了非常讨厌的 SQL、关系代数和关系微积分查询。我得到了这个查询：

查找从“计算机”类别订购所有产品的客户的姓名。（订购了计算机类别中所有产品的客户）

这是架构：

客户（Customer_Id、Cust_First_Name、Cust_Last_Name）

订单 ( Order_Id , *Customer_Id*)

Order_items ( Order_Item_id , *Order_Id*, *Product_Id*)

Product_info ( Product_Id , Product_Name, Category)

粗体（主键）、斜体（外键）

现在要将这个查询转换为关系代数，我需要使用连接而不是子查询。为了帮助自己一点，我首先编写 SQL，然后将 SQL 查询转换为关系代数。

这是我的尝试：

尝试 1（使用子查询）：

select C.Customer_Id
from Customer C
where
(
select count(*)
from product_info
where category = 'Computer'
)=(select count (distinct pi.Product_id)
from orders S, order_items OI, product_info pi
where S.Customer_Id = C.Customer_Id and S.Order_Id = OI.Order_Id and  pi.product_id=OI.product_id and category = 'Computer')

尝试 2（在有子句中使用一个子查询）：

select C.Customer_Id
from Customer C, Product_info pi, Orders S, Order_Items oi
where C.Customer_Id = S.Customer_Id and S.Order_Id = OI.Order_Id and OI.Product_Id = pi.Product_Id and pi.category = 'Computer'
group by C.Customer_Id
having count (distinct pi.Product_Id) = 
(
select count (*) 
from Product_info
where category = 'Computer'
)

尝试 3（from 子句中的子查询）：

select C.Customer_Id
from Customer C, Product_info pi, Orders S, Order_Items oi,
(
select count (*) num
from Product_info
where category = 'Computer'
) numbr
where C.Customer_Id = S.Customer_Id and S.Order_Id = OI.Order_Id and OI.Product_Id = pi.Product_Id and pi.category = 'Computer'
group by C.Customer_Id, numbr.num
having count (distinct pi.Product_Id) = numbr.num

现在这个查询可以用关系代数来表示，但它效率低下，因为它重复了值。

我的最后一次尝试（不编译并在 where 中使用子查询）：

select *
from Customer C
where not exists
(select *
from (select Order_Id from orders O where O.Customer_Id = C.Customer_Id) S INNER JOIN order_items OI on S.Order_Id = OI.Order_Id
RIGHT OUTER JOIN (select Product_Id from product_info where category ='Computer') PI on PI.Product_Id = OI.Product_Id
where OI.Product_Id = null)

我在某处读到，在这种情况下可以使用 LATERAL，但是关于 LATERAL 的信息太少，我无法正确理解。

考试结束了，但我仍然对解决方案感兴趣。因为这是 2 小时的考试，其中有 6 个查询、ER 图、ER-To-Relational、标准化到 BCNF、3NF，我想到这个查询怎么会这么难解决。我在这里错过了一些重要的东西吗？

这是一些小样本数据，可以帮助我一点：

http://pastebin.com/DkCe0AGm

提前致谢。

4

2 回答 2

2

这对于关系代数中的除法运算符非常容易。您应该注意，仅仅因为您可以用关系代数编写的任何东西都可以用 SQL 编写，但这并不意味着您可以用关系代数编写的任何东西都可以用 SQL 编写相同的方式。SQL 没有与除法运算符等效的简单方法，因此首先尝试在 SQL 中编写它不会有帮助。

由于我不知道如何在这里写希腊字母，所以我只是想写一些东西。

Sigma -> 选择
Pi -> 项目
Rho -> 重命名

PROJECT c.Cust_First_Name, c.Cust_Last_Name, i.Product_ID (SELECT c.customer_id = o.customer_id, o.order_id = i.order_id (RENAME (Customer c) X RENAME (Orders o) X RENAME (Order_items i))) 
DIVIDE PROJECT p.product_id (SELECT p.category = 'Computers' (RENAME (Products p)))

如果你把它输入到 LaTeX 编辑器中，你会看到它的实际形式：

\Pi_{c.cust\_last\_name, c.cust\_first\_name, i.product\_id} (\sigma_{c.customer\_id = o.customer\_id, o.order\_id = i.order\_id}(\rho_{c}(customer) X \rho_{o}(orders) X \rho_{i}(order\_items))) 
\div  \Pi_{p.product\_id}(\sigma_{p.category='computers'}(\rho_{p}(products)))

您可能会争辩说这是一个子查询，但我会说这只是两个不同的查询。

于 2012-06-22T16:17:32.860 回答
1

我觉得这个问题模棱两可。此版本获取仅从类别计算机订购产品的客户：

select c.customer_id, c.Cust_First_Name, c.Cust_Last_Name
from Customer c join
     Orders o
     on c.customer_id = o.customer_id join
     Order_Item oi
     on o.order_Id = oi.order_id join
     Product_Info pi
     on oi.Product_id = pi.product_id
group by c.customer_id, c.Cust_First_Name, c.Cust_Last_Name
having min(case when pi.category = 'Computer' then 1 else 0 end) = 1

在这种情况下，我只是在计算客户是否有任何未在该类别中购买的产品。

另一种解释是“订购了计算机类别中所有产品的客户”：

select c.customer_id, c.Cust_First_Name, c.Cust_Last_Name
from Customer c join
     Orders o
     on c.customer_id = o.customer_id join
     Order_Item oi
     on o.order_Id = oi.order_id join
     Product_Info pi
     on pi.Product_id = oi.Product_id cross join
     (select count(distinct product_id) as cnt
      from Product_info pi
      where category = 'Computer'
     ) comps
where pi.Category = 'Computer'
group by c.customer_id, c.Cust_First_Name, c.Cust_Last_Name
having count(distinct product_id) = comps.cnt

在这种情况下，想法是计算不同产品的数量并查看计数是否匹配。

我不确定将这些转换为关系代数是否真的有助于形成一个好的查询。

于 2012-06-22T15:04:16.757 回答