Question

大家好，我试图通过Arthmetic（Quanity * Unit_price）查找订单的总价值，但我可以这样做，但问题是希望我使用嵌套查询和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结尾。 / p>

（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

使用WITH子句乘法列

1 个答案: