使用 WITH 子句乘以列

Question

大家好，我试图通过算术（数量 * 单位价格）找到订单的总价值，我可以这样做，但问题希望我使用嵌套查询和 WITH 子句来这样做。如何实现 WITH 子句？

以下是我做过但不符合程序要求的情况

SELECT ORDER_ID
FROM ORDERS
WHERE ORDER_ID IN
(SELECT(QUANTITY * UNIT_PRICE) AS TOTAL_VALUE
FROM ORDER_DETAIL)
ODER BY ORDER_ID ASC;

CREATE TABLE ORDERS
(
    ORDER_ID        DECIMAL(9)  NOT NULL,
    CUSTOMER_CODE   VARCHAR(5)  NOT NULL,
    EMPLOYEE_ID     DECIMAL(9)  NOT NULL,
    ORDER_DATE      DATE        NOT NULL,
    REQUIRED_DATE   DATE,
    SHIPPED_DATE    DATE,
    SHIP_VIA        VARCHAR(40),
    FREIGHT         DECIMAL(10,2)           DEFAULT 0,
    SHIP_NAME       VARCHAR(40),
    SHIP_ADDRESS    VARCHAR(60),
    SHIP_CITY       VARCHAR(15),
    SHIP_REGION     VARCHAR(15),
    SHIP_POSTAL_CODE    VARCHAR(10),
    SHIP_COUNTRY    VARCHAR(15),
    CONSTRAINT PK_ORDERS PRIMARY KEY (ORDER_ID),
    CONSTRAINT FK_CUSTOMER_CODE FOREIGN KEY (CUSTOMER_CODE) REFERENCES CUSTOMER(CUSTOMER_CODE),  
    CONSTRAINT FK_EMPLOYEE_ID FOREIGN KEY (EMPLOYEE_ID) REFERENCES EMPLOYEE(EMPLOYEE_ID),  
    CONSTRAINT FK_SHIP_VIA FOREIGN KEY (SHIP_VIA) REFERENCES SHIPPER(COMPANY_NAME)  
);

CREATE TABLE ORDER_DETAIL
(
    ORDER_ID         DECIMAL(9) NOT NULL,
    PRODUCT_NAME     VARCHAR(40)    NOT NULL,
    UNIT_PRICE       DECIMAL(10,2)  NOT NULL    DEFAULT 0,
    QUANTITY         DECIMAL(9) NOT NULL    DEFAULT 1 ,
    DISCOUNT         DECIMAL(4,2)   NOT NULL    DEFAULT 0,
    CONSTRAINT PK_ORDER_DETAIL PRIMARY KEY (ORDER_ID, PRODUCT_NAME),
    CONSTRAINT FK_ORDER_ID FOREIGN KEY (ORDER_ID) REFERENCES ORDERS (ORDER_ID),
    CONSTRAINT FK_PRODUCT_NAME FOREIGN KEY (PRODUCT_NAME) REFERENCES PRODUCT (PRODUCT_NAME),
    CONSTRAINT CK_ORDER_DETAIL_UNIT_PRICE CHECK (UNIT_PRICE >= 0),
    CONSTRAINT CK_ORDER_DETAIL_QUANTITY CHECK (QUANTITY > 0),
    CONSTRAINT CK_ORDER_DETAIL_DISCOUNT CHECK (DISCOUNT between 0 and 1)
);

我想我可能需要使用这个表，但我不确定（表产品）

CREATE TABLE PRODUCT
(
    PRODUCT_NAME    VARCHAR(40)     NOT NULL,
    SUPPLIER_NAME   VARCHAR(40)     NOT NULL,
    CATEGORY_NAME   VARCHAR(30) NOT NULL,
    QUANTITY_PER_UNIT   VARCHAR(20),
    UNIT_PRICE      DECIMAL(10,2)   NOT NULL    DEFAULT 0,
    UNITS_IN_STOCK  DECIMAL(9)  NOT NULL    DEFAULT 0,
    UNITS_ON_ORDER  DECIMAL(9)  NOT NULL    DEFAULT 0, 
    REORDER_LEVEL   DECIMAL(9)  NOT NULL    DEFAULT 0,
    DISCONTINUED    CHAR(1)     NOT NULL    DEFAULT 'N',
    CONSTRAINT PK_PRODUCT PRIMARY KEY (PRODUCT_NAME),
    CONSTRAINT FK_CATEGORY_NAME FOREIGN KEY (CATEGORY_NAME) REFERENCES CATEGORY(CATEGORY_NAME),
    CONSTRAINT FK_SUPPLIER_NAME FOREIGN KEY (SUPPLIER_NAME) REFERENCES SUPPLIER(COMPANY_NAME),
    CONSTRAINT CK_PRODUCT_UNIT_PRICE CHECK (UNIT_PRICE >= 0),
    CONSTRAINT CK_PRODUCT_UNITS_IN_STOCK CHECK (UNITS_IN_STOCK >= 0),
    CONSTRAINT CK_PRODUCT_UNITS_ON_ORDER CHECK (UNITS_ON_ORDER >= 0),
    CONSTRAINT CK_PRODUCT_REORDER_LEVEL CHECK (REORDER_LEVEL >= 0),
    CONSTRAINT CK_PRODUCT_DISCONTINUED CHECK (DISCONTINUED in ('Y','N'))
);

这是一个确切的问题

插入到文件solution1.sql执行以下查询为 带有 WITH 子句的 SELECT 语句。

查找所有订单，使得每个订单的价值大于迄今为止提交的所有订单的平均值。在每行输出中列出一个订单标识符、一个订单的总值和所有订单的平均值。结果必须按每个订单的总值的降序排序。

“订单的总价值必须计算为订单中包含的所有商品的单价 * 数量的总和。查询必须作为 WITH 关键字后的子查询定义序列来实现，并以最终的 SELECT 结束。

(i) 第一个子查询定义必须找到每个订单的总值以及订单标识符（属性 order_id）。 "

我目前在 (i)

Answer 1

暂时忽略后续要求，第一段代码可能如下所示：

SELECT o.some
     , o.columns 
     , o.from_orders
     , x.total_value
  FROM orders o
  JOIN 
     ( SELECT order_id
            , SUM(quantity * unit_price) total_value 
         FROM order_detail 
        GROUP 
           BY order_id
     ) x
    ON x.order_id = o.order_id