Gordon Linoff

你可以用 left join .假设你有一张视频表:

CREATE VIEW videos_not_rented_this_month
    SELECT v.*
    FROM videos v LEFT JOIN
         loan l
         ON l.v_id = v.v_id AND
            l.loan_date >= curdate() + interval (1 - day(curdate())) day
    WHERE l.v_id IS NULL;   -- videos with no match

您可以通过数据模型实现这一点:

select t.*
from t join
     t tsingle
     on concat('&', t.room_name, '&') like concat('%', tsingle.room_name, '%')
where t.room_name like '%&%' and
      tsingle.room_name not like '%&%';

我建议修复数据模型,但这可能很棘手。我猜你想要一个 room_id 这涵盖了单间和相连的房间。所以,建议是为房间准备一张桌子,就像上面提到的那样,但是没有桌子 room_name (或者你可以离开它)。你可能想要一个 room_type 列,类似于“单个”或“链接”。

然后有一个单独的表与联系。在您的示例中,这实际上将包含您请求的结果集。

你可以用 last_day() 为了得到这个月的最后一天。然后 day() 提取 第()天 编号:

select day(last_day(now())) as days_in_current_month

还可以使用相关子查询:

select s.*,
       (select count(*)
        from books b
        where s.StudentID = b.StudentID
       ) as bookCount
from students s;

这比使用 join / group by 方法:

• 您可以轻松地将所有列包含在 select .他们不必在课堂上重复 分组 .
• 带索引的 books(StudentID) 这通常有最好的表现。
• 这避免了外部聚合,因为外部聚合可能会降低性能。
• 添加另一个维度(比如学生的课程数量)只会起作用,而不用担心笛卡尔积。

使用 union :

select birth_date
from players
union    -- on purpose to remove duplicates
select payment_date
from penalties;

使用 exists 而不是 LEFT JOIN s、 当存在多个匹配项时,连接只是将行相乘:

SELECT COUNT(*)
FROM trouble t
WHERE t.name LIKE '%keyword%' OR
      t.title LIKE '%keyword%' OR
      t.tags LIKE '%keyword%' OR
      EXISTS (SELECT 1
              FROM district d
              WHERE d.id = t.district AND d.district LIKE '%keyword%'
             ) OR
      EXISTS (SELECT 1
              FROM country c
              WHERE c.id = t.country AND c.country LIKE '%keyword%'
             ) OR
      EXISTS (SELECT 1
              FROM state s
              WHERE s.id = t.state AND s.state LIKE '%keyword%'
             ) OR
      EXISTS (SELECT 1
              FROM multi_category mc JOIN 
                   category ct
                   ON ct.id = mc.ct_id 
              WHERE mc.t_id = t.id AND
                    (ct.category LIKE '%keyword%' OR
                     c.country LIKE '%keyword%'
                    )
             );

通过消除多行的创建,这也应该更快。

这里有一种方法,使用字母数字作为有效字符:

select concat(substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1),
              substring('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', rand()*36+1, 1)
             ) as LicensePlaceNumber;

注:不保证唯一性。你得单独检查一下。

如果你真的需要性能,最好是在虚拟生成的列上建立第二个索引:

alter table mytable add column my_conditions int generated always as
    (thing in ('foo', 'bar') AND used IS NULL AND stime = 0 AND (~flags & 1) );

create index idx_mytable_my_conditions on (my_conditions, id desc)

然后,您可以通过以下方式查询该表:

SELECT *
FROM mytable 
WHERE my_conditions = 1
ORDER BY id DESC
LIMIT 1;

它应该使用索引进行过滤和排序。

你可以使用这样的逻辑:

where dayid = @dayid and
      ( (openTime < closeTime and @timetocheck between openTime and closeTime) or
        (openTime > closeTime and @timetocheck not between closeTime and openTime)
      )

group by 对所需尺寸进行过滤:

SELECT product_id, product_name
FROM product_attributes
WHERE size IN ('S', 'M', 'L')
GROUP BY product_id, product_name

那么你想要一个 ORDER BY . 不清楚你是否真的想要:

ORDER BY SUM(stock > 0) = 3 DESC

或:

ORDER BY SUM(stock = 0) ASC

或:

ORDER BY SUM(stock <> 0) DESC

0 在里面 stock .

按行数的第二个顺序 0个 0个 s在 列将排在第一位,其余的依次类推。

三等兵 在递减模式中不是零。

如果你有这样的数据,区别会很明显:

21      1            DEF         S      2
22      1            DEF         L      5

大概没有尺寸 M DEF . 你想在结果集中看到吗?这算不算全部库存?

首先,这个查询:

Select portt.nameport
From Portt 
Where  portt.toolsum - (select count(*) 
                        From tool               
                        Group by nameport
                       ) > 2;

你有一个 标量子查询 . 但是,如果可以返回多行,这将是一个错误。我猜您需要一个相关的子查询:

select p.nameport
from Portt p
where p.toolsum - (select count(*) 
                   from tool t          
                   where t.nameport = p.nameport
                  ) > 2;

那么, JOIN 操作人员 在 FROM 从

select p.nameport
from Portt p join
     tool t
     on t.nameport = p.nameport
where p.toolsum - (select count(*) 
                   from tool t          
                   where t.nameport = p.nameport
                  ) > 2;

我想写得简单一点:

SELECT p.id, p.title, p.price, p.status,
       (SELECT COUNT(*)
        FROM payments pa
        WHERE pa.product = p.id AND
              pa.vendor = p.member AND
              pa.credited = 'Vendor' AND
              pa.status IN ('Completed', 'Pending', 'Canceled_Reversal')
      ) AS sales,
       (SELECT SUM(pa.price)
        FROM payments pa
        WHERE pa.product = p.id AND
              pa.vendor = p.member AND
              pa.credited = 'Vendor' AND
              pa.status IN ('Completed', 'Pending', 'Canceled_Reversal')
      ) AS revenue
FROM products p
WHERE p.member = 1 AND
      p.status NOT IN ('Deleted', 'Blocked');

这基本上是您的查询,具有更简单的别名和逻辑。

上有索引 payments(product, vendor, credit, status, price) ,这可能比其他方法更快。

另一种选择是:

SELECT p.id, p.title, p.price, p.status,
       COUNT(pa.product) as sales
       SUM(pa.price) as revenue
FROM products p LEFT JOIN
     payments pa
     ON pa.product = p.id AND
        pa.vendor = p.member AND
        pa.credited = 'Vendor' AND
        pa.status IN ('Completed', 'Pending',     
WHERE p.member = 1 AND
      p.status NOT IN ('Deleted', 'Blocked')

'已取消'

但是,子查询可能更快。

有一个表达式可以从数据库的列中提取“公司名称”。

count(distinct) :

SELECT count(DISTINCT SUBSTRING_INDEX(REPLACE(nextgenorder_companyname, '/', ' '), ' ',1)
            ) as company, 
       nextgenorder_deliverydate as ShipDate 
FROM nextgenorders2 
WHERE nextgenorder_deliverydate = '2020-11-11' 
GROUP BY nextgenorder_deliverydate;

Here 是db<gt;小提琴。

使用 left join . 而不是 group by 需要:

SELECT U.id AS id, U.amount AS amount, A.commission AS commission,
      I.power AS item_power
FROM affiliate A JOIN
     users U
     ON A.owner_id = U.id JOIN
     users_booster B
     ON U.id = B.userid LEFT JOIN
     auction_item I
     ON B.item_id = I.id AND I.type = 'reference_booster'
WHERE A.partner_id = 1947 AND 
      B.end_time >= NOW();

• 使用 LEFT JOIN 无论何时你想保留行,即使没有匹配。
• 第二 中的表 左连接 需要在 ON 条款。
• partner_id 是一个数字,所以不要将其与字符串进行比较。使用 1947 而不是 '1947' . 当然,如果是字符串,请保留单引号。
• GROUP BY 在没有聚合函数的情况下很少有意义。

SELECT ab.*
FROM authorbiographies ab
WHERE ab.authorname NOT LIKE '% and %';

你似乎只想挑出那些没有 ' and ' 在他们身上。

我建议在 where 条款:

SELECT c.*, o.*  -- or whatever columns you want
FROM customers c JOIN
     orders o
     ON c.id = o.customer_id
WHERE o.order_date = (SELECT max(o2.order_date)
                      FROM orders o2
                      WHERE o2.customer_id = o.customer_id
                     );

实际上你不需要函数来实现这个。MySQL理解间隔算法:

select startdate + interval duration month

显式列出所需的列。不使用 select * :

SELECT m.id, m.userid, m.movie_id, m.status, m.score,
       md.name_de, md.name_en, md.description, md.url
FROM `movie` m LEFT JOIN 
     movie_data md
     ON m.movie_id = md.id
ORDER BY m.id

你的语法没有意义。也许这就是你的意图:

create temporary table tempTable as
    select game_date, home_team, inning, inning_topbot, 
           (case when inning_topbot = 'top' then away_score
                 else home_score
            end) as innType
    from pitchdata;

你有一个非常奇怪的数据模型。我不知道一个 order_id 将与多个用户关联,但这似乎是您正在做的。

我认为将不同的sku放在不同的行上更容易,因此我将从以下几点开始:

SELECT o.order_id, o.order_sku,
       COUNT(DISTINCT o.user_id) / COUNT(DISTINCT a.user_id)
FROM Order o LEFT JOIN
     Advertising a
     ON o.user_id = a.user_id
GROUP BY o.order_id, o.order_sku;

您可以使用聚合:

select user_login
from wp_login_log_backup llb
group by user_login
having max(date) < '2017-04-07';

这段代码基本上看起来是正确的。我会把它写成:

UPDATE songs s
    SET artist_id = (SELECT a.artist_id 
                     FROM artists a 
                     WHERE a.name = s.artist
                    );

如果此查询返回错误,则 artist_id 不在 artists . 你可能想要 a.id .

如果此查询不更新任何内容,则 艺术家id s已经具有相同的值。

你可以用 update 用一个 join :

update abcd join
       (select id, inAmt, outAmt,
               @prev := if(id = 1, @prev := @curBalance , @prev + (@prevOut-@prevIn)) as balance,
               @prevIn := inAmt,
               @prevOut := outAmt
        from (select @prev := 0) as i cross join
             abcd
        order by id
       ) x
       on abcd.id = x.id
    set abcd.newbalance = x.balance;

尽管如此,您的查询绝对不能保证有效,并且随时可能失败。在一个表达式中使用变量并在另一个表达式中分配它们。mysql不保证表达式的求值顺序。

不过,这不是你问的问题。如果要修复查询,请使用示例数据和所需结果提出新问题。

如果每个产品只有一行,即使有多个最低价格,也可以按 id 而不是 price 是的。

这看起来像

SELECT p.id, p.name, pr.price, pr.price_init
FROM products p LEFT JOIN
     prices pr
     ON pr.product_id = p.id AND
        pr.id = (SELECT pr2.id
                 FROM prices pr2
                 WHERE pr2.product_id = pr.product_id
                 ORDER BY pr2.price
                 LIMIT 1
                );

Here 是一个SQL小提琴。

注意在mysql 8+中,您将使用窗口函数:

SELECT p.id, p.name, pr.price, pr.price_init
FROM products p LEFT JOIN
     (SELECT pr.*,
             ROW_NUMBER() OVER (PARTITION BY pr.product_id ORDER BY pr.price) as seqnum
      FROM prices pr
     ) pr
     ON pr.product_id = p.id AND pr.seqnum = 1;

你应该修正你的数据模型!不要把东西的清单——特别是数字——存储在一个字符串中。sql有一个很好的存储列表的数据模型:它被称为 桌子 是的。

如果你真的,真的,真的很糟糕地选择了其他人的DTA模型,你可以在里面工作。MySQL有一个方便的功能, find_in_set() ,这就是你想要的:

WHERE find_in_set('0', list) > 0

几乎可以与 NULL 是 无效的 --被认为是假的。包括不等式。这就是为什么sql IS NULL 和 IS NOT NULL .

但是,我建议您将代码编写为:

SELECT s.shape, COUNT(sp.price)
FROM shapes s LEFT JOIN
     shape_purchase sp
     ON s.id = sp.id
GROUP BY s.id;

COUNT(<expression>) 算不算- 无效的 价值观。不需要条件逻辑。

使用相关的子查询可能会更好:

UPDATE feed.product fp 
    SET fp.images = (SELECT GROUP_CONCAT(DISTINCT(CONCAT ('https://www.example.com/', pi.`id_image`,'-x_shop/',pl.link_rewrite,'.jpg')) SEPARATOR ",")  AS images
                     FROM db.image pi JOIN
                          db.product_lang pl
                          ON pi.id_product = pl.id_product
                     WHERE fp.id_product = pi.id_product
                    )    
    WHERE fp.image_updated = 1;

如果只有少数行 fp 正在更新。

这是您的问题:

select activity
from (Select activity, count(*)
      from FRIENDS
      group by activity
     ) as getActivities
where count not in (Select min(count) from (Select activity, count(*) from FRIENDS group by activity ) as maximum,
                    SELECT max(count) from (Select activity, count(*) from FRIENDS group by activity) as minimum
                   );

您有多个错误。例如:

• count(*) 没有列别名。但它需要一个名称,因为它在子查询中。
• 子查询没有表别名。
• 外部的子查询 where 有括号。
• 这个 , 意味着您打算将子查询作为标量子查询,但它们可以返回多行。

我想你打算:

select f.activity
from friends f
group by f.activity
having count(*) > (select count(*)
                   from friends f2
                   group by f2.activity
                   order by count(*) asc
                   limit 1
                  ) and
       count(*) < (select count(*)
                   from friends f2
                   group by f2.activity
                   order by count(*) desc
                   limit 1
                  );

如果我理解正确的话,你会得到 @date , @start_time 和 @end_time 你想在桌子上登记。

要返回所有重叠:

SELECT b.*
FROM booking b
WHERE @date = b.date AND
      @end_time >= b.start_time AND
      @start_time < b.end_time;

你在找 insert on duplicate key update .

基本上,你想要组合 (userId, questionId) 独一无二。首先设置唯一约束/索引:

create unique index unq_t_userId_questionId on t(userId, questionId);

然后使用 on duplicate key update 插入内容:

insert into t (userId, questionId, selectedId)
    values (@userId, @questionId, @selectedId)
    on duplicate key update selectedId = values(selectedId);

你的问题有多个部分。如果你想要 0 值,则需要外部联接或相关子查询。我想你有一张所有比赛的桌子,但是 select distinct 上 entries 桌子也能用。

如果你想让大多数人崩溃 每辆车 你需要一个 汽车 中的标识符 crashes 表。我肯定有一个(这很有道理),但你不会在问题中描述它。我猜大概是 c_raceEntryCarId .

结果查询如下所示:

select e_racename, e.e_racedate,
       (select count(*)
        from crashes c
        where c.c_racename = e.e_racename and c.e_racedate = e.e_race_date 
        group by c.c_raceEntryCarId
        order by count(*) desc
        limit 1
       ) as most_crashes
from (select e.e_racename, e.e_racedate
      from entries e
      group by e.e_racename, e.e_racedate
     ) e;

如果您只想知道每次比赛的崩溃次数,那么子查询将有所不同:

select e_racename, e.e_racedate,
       (select count(*)
        from crashes c
        where c.c_racename = e.e_racename and c.e_racedate = e.e_race_date
       ) as most_crashes
from (select e.e_racename, e.e_racedate
      from entries e
      group by e.e_racename, e.e_racedate
     ) e;

在MySQL中,可以使用相关的子查询:

select l.*
from locations l
where l.id = (select l2.id
              from locations l2
              where l2.name = l.name
              order by (feature_code = 'RGN') desc,  -- put regions first
                       id asc
             );

在MySQL 8 +中,也可以使用 row_number() :

select l.*
from (select l.*,
             row_number() over (partition by name 
                                order by (feature_code = 'RGN') desc, id
                               ) as seqnum
      from locations l
     ) l
where seqnum = 1;

我认为这是可行的:

SELECT ka.kodeagent
       (SELECT COUNT(1)
        FROM bsn_data d
        WHERE d.periode >= '2018-12-01' AND
              d.periode < '2019-01-01' AND
              d.kodeupline2 = ka.kodeagent AND
              d.kodeagent = (SELECT d2.kodeagent
                             FROM bsn_data d2
                                  d2.periode >= '2018-12-01' AND
                                  d2.periode < '2019-01-01' AND
                                  d2.kodeupline2 = ka.kodeagent
                             GROUP BY d2.kodeagent
                             ORDER BY COUNT(1) DESC
                             LIMIT 1
                            )
        ) AS totps
FROM bsn_kode_agent ka
WHERE ka.fungsi = 'sales agent'
ORDER BY totps DESC;

笔记:

• 不要在日期上使用字符串操作!使用正确的日期操作。
• 使用表别名并限定表名。
• = 可以使用 limit 虽然,虽然 in 不能。
• COUNT() 不回来了 NULL ,所以不需要 无效的 比较。

我仍然认为这个查询不起作用,因为您有一个双重嵌套的correlation子句。但这确实解决了你眼前的问题。

如果还是不行,就问 另一个 提出问题,提供示例数据、所需的结果,并解释要实现的逻辑。

你为什么要用循环来做这个?只做:

 INSERT INTO `forum_topicresponder` (topic_id, username, reply_id)
     SELECT p.topic_id, p.creator_name, p.id
     FROM forum_post p
     WHERE p.topic_id <= 665;  -- or use a variable if you prefer

您的查询只是一个错误的查询,因为您正在使用 select * 具有 group by . 此查询使用MySQL扩展。而且,mysql最新版本中的默认设置将生成错误。

下面是一种将此转换为SQL Server的方法:

SELECT TOP (1) WITH TIES * 
FROM Table1 AS T1 INNER JOIN
     Table2 AS T2 
      ON T1.Column1 = T2.ColumnX 
WHERE T1.ColumnY = 'xxxx' 
ORDER BY ROW_NUMBER() OVER (PARTITION BY T1.Column1 ORDER BY (SELECT NULL)) ;

可能更好的方法(从性能角度)是使用横向连接:

SELECT * 
FROM Table1 T1 CROSS APPLY
     (SELECT TOP (1) T2.*
      FROM Table2 T2 
      WHERE T1.Column1 = T2.ColumnX 
     ) T2
WHERE T1.ColumnY = 'xxxx' ;

这两个选项都从中选择任意行 Table2 当比赛不止一场时。

我只想用 exists :

SELECT c.cl_id , c.cl_name_last 
FROM vt_clients c 
WHERE EXISTS (SELECT 1
              FROM vt_animals a
              WHERE c.cl_id = c.cl_id AND
                    a.an_type NOT IN ('snake', 'lizard', 'turtle')
            );

你只需要一种非爬行动物的存在,所以没有必要 count() .

我想到了四个选择。首先是在应用程序中执行所有检查。可行,但不是你所要求的。

第二个是为 insert 和 update . 他们将拒绝在前10个月之后的任何额外任命。

第三个是10列,每个约会时段一列。

第四种选择是预先填充一个日历表,其中的槽位于单独的行中。然后更新所需的插槽。

我绝对不是第三选择的粉丝,但我会用它来回答你的问题。

我倾向于选择第四种或第一种。

可以在中使用表达式 order by . 所以:

order by (case when title like concat('%', @search_term, '%') then 1 else 2 end),
         (case when description like concat('%', @search_term, '%') then 1 else 2 end)

在mysql中,这可以简化为:

order by (title like concat('%', @search_term, '%')) desc,
         (description like concat('%', @search_term, '%')) desc

您还可以为此使用相关子查询:

select lt.*
from temp_laptimes lt
where lt.laptime = (select min(lt2.laptime)
                    from temp_laptimes lt2
                    where lt2.lapdate <= lt.lapdate
                   );

但是,gmb提出的累积窗口函数在mysql 8+中表现得更好。

我想一个索引 ActivityX(user, ActivityNum) 会解决你的问题。

我猜你有个索引 (ActivityNum) 优化器正试图找出是否应该使用索引。这会导致阈值。复合索引应该更好地匹配查询。