你可以用 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);