标签: subquery

给出下表：

CREATE TABLE IF NOT EXISTS `rank` ( 
`rank_id` bigint(20) NOT NULL AUTO_INCREMENT, 
`rank` int(10) NOT NULL DEFAULT '0', 
`subject_id` int(10) NOT NULL DEFAULT '0', 
`title_id` int(10) NOT NULL DEFAULT '0', 
`source_id` int(10) NOT NULL DEFAULT '0'
PRIMARY KEY (`rank_id`) 
) ENGINE=MyISAM; 

INSERT INTO `rank` (`rank_id`, `rank`, `subject_id`, `title_id`, `source_id`) VALUES 
(23, 0, 2, 1, 1), 
(22, 0, 1, 1, 1), 
(15, 0, 2, 2, 2), 
(14, 0, 2, 2, 1), 
(20, 0, 1, 3, 2), 
(18, 0, 1, 4, …

我有一个函数，它将用户的 id 作为参数并使用该参数执行操作。我想为多个用户调用该函数。

对于单个用户，我成功使用：

SELECT myFuncFoo(1);

对于多个用户，我尝试了这个但没有运气：

SELECT users.id as uid, 
(SELECT myFuncFoo(uid))
FROM users;

我也尝试过不使用别名：

SELECT users.id,
(SELECT myFuncFoo(users.id))
FROM users;

我怎样才能实现这个目标？

的基本语法DELETE是

DELETE FROM table
WHERE condition

是否有一种直接的方法可以在DELETE语句中使用子查询/别名，如下所示？

DELETE FROM (subquery) as sub
WHERE condition

下面是一个最小的工作表，我尝试使用子查询/别名失败：

---create table
create table orderT (
    id integer PRIMARY KEY,
    country_code   varchar(2),
    created_date date,
    closed_date date);

---populate table
INSERT INTO orderT VALUES (1, 'US', now(), now() + interval '1 day' * 21);
INSERT INTO orderT VALUES (2, 'CA', now(), now() + interval '1 day' * 35);

--This does not work    
    DELETE
    FROM
      (SELECT *
       FROM orderT) AS sub
    WHERE sub.id = …

有人可以解释如何执行此查询：

我必须选择没有重复“idPrdodotto”的所有字段

那是我不工作的查询：

SELECT *
FROM riempie1
WHERE idProdotto IN (SELECT DISTINCT idProdotto
                     FROM riempie1
                    );

我遇到了一个问题，Sequelize 创建主模型的子查询，然后将包含与该子查询连接起来，而不是直接与主模型表连接。包含的查询条件最终位于子查询的 WHERE 子句中，这使其无效。我已经缩短了名字，希望能保持这种紧凑，而不会丢失任何相关信息。

环境：Nodejs: 6.11.3 Sequelize: 3.23.6 => 更新到 4.38.1 问题依旧 MySql: 5.7.23

代码截图模型：

I.model:
   models.I.hasMany(models.II);
   models.I.belongsTo(models.CJ);
   models.I.belongsTo(models.CJS);
II.model:
   models.II.belongsTo(models.I);
CJ.model:
   models.CJ.hasMany(models.I);
   models.CJ.hasMany(models.CJS);
CJS.model:
    models.CJS.hasMany(models.I);

代码片段查询定义：

let where = { cId: '2',
iAmt: { '$gt': 0 },
'$or': 
 [ { '$CJ.a1$': {$like: '%246%'}} },
   { '$CJ.a2$': {$like: '%246%'} },
   { '$I.cPN$': {$like: '%246%'} } 
 ] };

 let query = {
   where: where,
   order: orderBy,
   distinct: true,
   offset: offset,
   limit: limit,
   include: [
   {
    model: CJ, 
    as: 'CJ',
    required: false …

我有一个 PostgreSQL 查询，它产生以下结果：

SELECT   o.order || '-' || osh.ordinal_number AS order, 
         o.company,
         o.order_total,
         SUM(osh.items) AS order_shipment_total,
         o.order_type
FROM     orders o
         JOIN order_shipments osh ON o.order_id = osh.order_id
WHERE    o.order = [some order number]
GROUP BY o.order,
         o.company,
         o.order_total,
         o.order_type;

order   | company | order_total | order_shipment_total | order_type
-------------------------------------------------------------------
123-1   | A corp. | null        |  125.00              | new
123-2   | B corp. | null        |  100.00              | new

我需要替换o.order_total（它不能正常工作）并总结 order_shipment_total 列的总和，这样，对于上面的例子，每一行都说 225.00。我需要上面的结果如下所示：

order   | company | order_total …

让我们在 Oracle 中进行一个简单的查询：

SELECT
    CASE.ID,
    CASE.TYPE,
    CASE.DATE_RAISED
FROM
    CASE
WHERE
    CASE.DATE_RAISED > '2019-01-01'

现在假设另一个表 EVENT 包含多个事件，这些事件可能与每个案例相关联（通过 EVENT.CASE_ID 链接）。或根本不存在。我想报告每个案例中最早日期的未来事件 - 或者如果不存在，则返回 NULL。我可以使用 SELECT 子句中的子查询来做到这一点，如下所示：

SELECT
    CASE.ID,
    CASE.TYPE,
    CASE.DATE_RAISED,
    (
    SELECT
        MIN(EVENT.DATE)
    FROM
        EVENT
    WHERE
        EVENT.CASE_ID = CASE.ID
        AND EVENT.DATE >= CURRENT_DATE
    ) AS MIN_EVENT_DATE
FROM
    CASE
WHERE
    CASE.DATE_RAISED > '2019-01-01'

这将返回一个像这样的表：

Case ID Case Type   Date Raised Min Event Date
76      A           03/01/2019  10/05/2019
43      B           02/02/2019  [NULL]
89      A           29/01/2019  08/07/2019
90      A           04/03/2019  [NULL]
102     C           15/04/2019  20/05/2019

请注意，如果不存在任何符合条件的事件，则仍会返回该行但没有值。这是因为子查询在 …

有两个表Document和DocumentPos。在Document有列GUID和在DocumentPos是DocumentGUID指表的列Document。

我想让每一行都在DocumentPos它DocumentGUID现在的行中Documents' GUID。

我有这个返回 0 行的查询：

select *
FROM             Document d,
                 DocumentPos dp
WHERE            d.GUID = dp.DocumentGUID
AND              dp.DocumentGUID NOT IN (
                 SELECT d.GUID
                 FROM Document
)

但是当我执行select * from documentpos它时，例如返回一行DocumentGUID= B479BCB72334424DAC1B7CC26880DAB8。这DocumentGUID是NOT IN表Document作为GUID.

但select * from Document where GUID = 'B479BCB72334424DAC1B7CC26880DAB8'返回 0 行。

我想像这样构建查询，因为它应该成为一个DELETE …

这是我的数据

Code    SubCode    Colour     Fruit     Car     City     Name
A       A1         Red        Apple     Honda   Mel      John
A       A1         Green      Apple     Toyota  NYC      John
A       A1         Red        Banana    Honda   Lon      John
A       A1         Red        Banana    Opel    Mel      John
A       A2         ...
A       A2         ...
A       A3
A       A3

这是我的sql

SELECT Code, SubCode, STRING_AGG(Colour, ',') STRING_AGG(Fruit, ',') STRING_AGG(Car, ',') STRING_AGG(City, ',') STRING_AGG(Name, ',')
FROM myTable

我得到这个结果

Code    SubCode    Colour              Fruit                       Car                      City     Name
A       A1         Red,Green,Red,Red   Apple,Apple,Banana,Banan    Honda,Toyota,Honda,Opel  ...

有没有办法让我的价值观与众不同

对于单个值，我可以创建一个子查询STRING_AGG？ …

我有以下数据

Emp.  Log data
A1.   20-JAN-2020 13:15:00
A1.   20-JAN-2020 12:00:00
A1.   20-JAN-2020 10:50:00
A1.   20-JAN-2020 07:00:00

从上面，我想导出登录注销数据。所以 0700 AM 是第一次登录，然后提前期是注销。再次记录下一个时间。即，12:00:00

预期结果：

Emp   login                logout 
A1.   20-JAN-2020 07:00:00 20-JAN-2020 10:50:00
A1.   20-JAN-2020 12:00:00  20-JAN-2020 13:15:00