GMB

我认为你需要替换这个:

select ...
into outfile ...
fields terminated by ';' lines starting by 'Edit: ' lines terminated by '\n'

使用:

select ...
into outfile ...
fields terminated by ';' lines starting by 'Edit: ' terminated by '\n'

lines 关键字不应重复。

总的来说 null

可能至少有一列有 这些记录的价值。在MySQL(和大多数其他RDBMS)中, 1 + null 产量 无效的 coalesce() :

coalesce(Metering0, 0) + coalesce(Metering1, 0) + coalesce(Metering2, 0) + ...

第4行显示1064错误

column_alias = <expression> 不是有效的MySQL语法(这是SQL Server语法)。你应该把列别名放在表达式后面,可选的是keyworkd as

coalesce(Metering0, 0) + coalesce(Metering1, 0) + coalesce(Metering2, 0) + ... as total 

从数据库的角度来看,您通常会对相应的表列设置一个唯一的约束:

create table users (
    id int auto_increment primary key,
    name varchar(50) not null,
    email varchar(100) not null unique
);

设置好后,任何试图生成重复项的查询 email (来自 INSERT 或者 UPDATE )会因为一个独特的违例错误而失败。

你可以使用 update ... join 语法:

update strankep s
cross join (select max(strp_aa) max_strp_aa from strankep) m
set s.strp_aa = m.max_strp_aa + 1
where s.strp_id = 36 and s.strp_aa is null

这个 cross join 使 strp_aa 在整张桌子上。这个 where 子句删除行 不是 null

如果你运行的是MySQL 8.0,你可以使用 lag() :

select *
from (
    select 
        l.*,
        lag(logs_status) over(
            partition by logs_id 
            order by logs_updated
        ) lag_log_status
    from logs l
) t
where log_status <> lag_log_status

要检查一个图像是否有两个不同的标记,需要跨行比较值,这反过来又建议聚合:

select m.id, m.name
from medias m
inner join medias_taglinks t on t.media_id = m.id
where t.tag_id in (1, 2)
group by m.id, m.name
having min(t.tag_id) <> max(t.tag_id)

查询过滤两个搜索的标记,按媒体聚合,并确保两个标记都存在。

id | name
-- | ----
1  | Media 1

如果要处理两个以上的标记,下面是一种更通用的方法:

select m.id, m.name
from medias m
inner join medias_taglinks t on t.media_id = m.id
where t.tag_id in (1, 2, 3, 4)
group by m.id, m.name
having count(*) = 4

假设没有重复 (media_id, tag_id) having count(distinct t.tag_id) = 4 .

旁注:the left join 似乎没有必要;如果要在媒体中搜索标记,无论如何都需要带上tab表。

这里的问题是不理解的 字符串插值

你用的是双引号( " )将查询字符串分配给 $q ,但它包含一个arobas( @ ),这是插值的。

q美元 最终包含:

SELECT SUBSTRING(AR_email, LOCATE(', AR_email) + 1) AS domain
FROM carrier
WHERE AR_email IS NOT NULL
AND SUBSTRING(AR_email, LOCATE(', AR_email) + 1) =?

如果你把这个放在下面 use warnings ,您将收到以下消息:

Possible unintended interpolation of @' in string

my $q = q/SELECT SUBSTRING(AR_email, LOCATE('@', AR_email) + 1) AS domain  
         FROM carrier 
         WHERE AR_email IS NOT NULL 
         AND SUBSTRING(AR_email, LOCATE('@', AR_email) + 1) =?/; 

故事的寓意:

• 仅当您 做

• 总是 use strict; use warnings;

问题不在 LINES TERMINATED BY 但是在 ESCAPED BY

这:

ESCAPED BY '\'  

你需要避开反斜杠,就像这样:

ESCAPED BY '\\'  

或者,您也可以使用 '\b' :

ESCAPED BY '\b'  

另一个问题是 OPTIONALLY ENCLOSED 只接受一个字符,同时给它两个单引号。

在您的查询中:

SELECT *  FROM tablename WHERE work_complete = 'Yes' 
INTO OUTFILE 'C:\file path for the file to be exported to\file_name.csv'   
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY "'" ESCAPED BY '\\'  
LINES TERMINATED BY '\n'

您可以使用聚合:

SELECT DOC_OwnerID
FROM mytable
WHERE  @mydate >= DOC_start_date AND @mydate <= DOC_end_date
GROUP BY DOC_OwnerID
HAVING
    MAX(DOC_type = 'JANUARY') = 1
    AND MAX(DOC_type = 'DRIVER') = 1
    AND MAX(DOC_type = 'LICENSE') = 1

DOC_OwnerID 是的,对于给定的 @mydate 参数,三个都有 DOC_type

如果你运行的是MySQL 8.0,你可以使用 regexp_replace() :

update posts
set products = regexp_replace(
    post_content, 
    '<h1 class="visible-xs">[^<]+</h1>', 
    '<h1 class="visible-xs"></h1>'
)

这假设要删除的字符串不包含字符 '<'

计算列不能引用其他表中的列(它只看到自己表行上的值)。

相反,您可以使用一个触发器来触发 event cost 从其他表/列:

delimiter |
create trigger trg_event_price
before insert on event
for each row
begin
    if new.cost is null then
        set new.cost = 
            (select popularity from artist where id = new.artist_id)
            * (select reputation from stage where id = new.stage_id)
        ;
    end if;
end
|
delimiter ;

设置好这个触发器后,就可以忽略列 成本 什么时候 insert 事件 ,然后让触发器处理它:

insert into event (artist_id, stage_id) values(1, 5);
-- "cost" will be computed from the popularity of artist 1 and the reputation of stage 5

你可以 cross join 生成所有可能组合的国家/地区和型号表,然后使用 left join :

SELECT 
    c.name as country_name,
    m.name as model_name, 
    IFNULL(SUM(s.quantity * m.price),0) as revenue 
FROM 
    country c
    cross join model m
    left join sales s
        on s.model_id = m.id
        and s.country_id = c.id
        and s.sales_date >= '2017-01-01' 
        and s.sales_date <  '2018-01-01'    
group by c.id, m.id, c.name, m.name
order by c.id, m.id;

注意,我在查询中做了以下更改:

• sales_date

• 将所有非聚合列添加到 group by ONLY_FULL_GROUP_BY ,默认情况下从MySQ 5.7开始启用

有一种方法:

delete t1
from mytable t1
inner join mytable t2
    on  t2.brand = t1.brand
    and t2.model = t1.model
    and t2.id < t1.id

这将删除上的重复项 (brand, model) 同时保留最小id的那个。

date_add() :

 date_add(my_date, interval my_num month) as my_new_date

my_date 是日期(或日期时间)数据类型和 my_num 是一个整数。

您需要枚举 SELECT 子句并使用别名消除同名列的歧义:

SELECT
    m.id,
    m.user_id,
    m.movie_id,
    m.status,
    m.score,
    d.id data_id,   --> column alias
    d.name_de,
    d.name_en,
    d.description,
    d.url
FROM movie m 
LEFT JOIN movie_data d ON m.movie_id = d.id 
ORDER BY m.id

MySQL Invisible Indexes ,它介绍了 VISIBLE 关键字,自8.0版以后可用。您可能运行的是早期版本。

该功能称为 看不见的 索引:这表明,在早期版本的MySQL中,索引总是可见的。即使在MySQL 8.0中,默认情况下索引也是可见的,除非显式定义为 INVISIBLE .

您可以安全地移除 可见的 脚本中的关键字,它在所有版本的MySQL上都应该工作得很好(并且一致)(假设该表 WORKOUT 它有一个唯一的列 IdWorkout 数据类型的 INT ).

Demo on DB Fiddle

您可以根据输入的分钟数生成时间表达式 SEC_TO_DATE (接受若干秒),然后将其作为第二个参数传递给 ADDTIME :

ADDTIME('09:00', SEC_TO_TIME(@minutes * 60))

我想使用来自列x,y(可以是一个或几个)的新值根据来自列a,b,c(可以是几个)的匹配值更新SQL表。

您正在使用的SQL代码看起来不像是有效的MySQL语法,与您试图实现的目标相比,它似乎过于复杂。

我相信您的需求可以用pseudo SQL概括如下:

UPDATE mytable SET {assignments} WHERE {conditions}

细节:

• {conditions} 选择要更新的记录:可以是 a = ? AND b = ? AND c = ? ,或者只是 a = ? ,或任何你需要的东西。

• {assignments} 设置值:例如: x = ?, y = ? ,或 x = ? ,所以一个

示例:set x 到3和 y 至5,其中 a 是1

UPDATE mytable SET x = 3, y = 5 WHERE a = 1

下面是SQL查询中逻辑的转换:

SELECT i.start, i.end, COUNT(*) number_of_rooms
FROM rooms i
LEFT JOIN rooms j ON i.start < j.end AND i.start  > j.start
GROUP BY i.start, i.end 

查询处理表中的每个记录(别名 i ). self join在同一个表中拉入所有记录( j )满足时间间隔重叠条件的。然后 GROUP BY 子句聚合每个记录的数据 我 ,和 COUNT() 提供中匹配记录的数目 j型 .

您可以使用关联的子查询进行筛选,该子查询提取每个会话的最新消息的日期:

select t.*
from mytable t
where 
    2 in (from_user, to_user)
    and t.msg_date = (
        select max(t1.msg_date)
        from mytable t1
        where 
            least(t1.from_user, t1.to_user) = least(t.from_user, t.to_user)
            and greatest(t1.from_user, t1.to_user) = greatest(t.from_user, t.to_user)
    )

Demo on DB Fiddle

id | from_user | to_user | content | msg_date  
-: | --------: | ------: | :------ | :---------
 7 |         7 |       2 | test7   | 2019-12-07
 8 |         5 |       2 | test8   | 2019-12-08

我检查一下凯特是否已经存在于表中。如果存在,则返回表中的行,如果不存在,则不返回任何内容。

你可以用 UNION :

select *
from (
    select id, name from classA
    union select id, name from classB
) t
where name = 'Kate'

或者,如果要知道从哪个表中找到了名称:

select *
from (
    select id, name, 'classA' tab from classA
    union all select id, name, 'classB' from classB
) t
where name = 'Kate'

注意:如果两个表中都存在名称,则第二个查询将生成两行。

你的质疑是个好的开始。对于你的样本数据,它会给你结果。为了满足您的要求,您只需要几个附加的过滤器:

select b.user_id, p.id
from bans b
inner join players p 
    on  p.id = b.user_id
    and p.score < 250
where b.reason = 'cheating'

从你的要求和评论来看 LIKE 接线员应该非常接近你的需要:

SELECT *
FROM mytable
WHERE mycolumn LIKE 'Status Changed from % to Completed'

这将允许任何字符序列作为以前的状态。

否则,如果预先知道可能的状态值列表,则可以使用regexp使筛选更精确:

SELECT *
FROM mytable
WHERE mycolumn REGEXP 'Status Changed from (Needs Action)|(Open) to Completed'

这个 REGEXP operator 检查列中的值是否与给定的正则表达式匹配。管子( | )代表 交替 运算符(至少有一个值必须匹配)。

Demo on DB Fiddle

create table mytable (
  mycolumn varchar(500)
);

insert into mytable values 
    ('Status Changed from Needs Action to Completed'),
    ('Status Changed from Open to Completed'),
    ('Not a relevant record');

查询1

SELECT *
FROM mytable
WHERE mycolumn LIKE 'Status Changed from % to Completed';

| mycolumn                                      |
| --------------------------------------------- |
| Status Changed from Needs Action to Completed |
| Status Changed from Open to Completed         |

问题2

SELECT *
FROM mytable
WHERE mycolumn REGEXP 'Status Changed from (Needs Action)|(Open) to Completed';

| mycolumn                                      |
| --------------------------------------------- |
| Status Changed from Needs Action to Completed |
| Status Changed from Open to Completed         |

根据现有的查询,可以进行日期运算。考虑:

SELECT t.* FROM (
    SELECT MAX(tgl_harga) AS maxdate
    FROM tbl_dummy
    GROUP BY 
        DATE(tgl_harga), 
        FLOOR(HOUR(tgl_harga) / 2)
) AS g 
INNER JOIN tbl_dummy t ON g.maxdate = t.tgl_harga
ORDER BY t.tgl_harga DESC

这将为每个固定的2小时窗口提供一条记录,这是该窗口中的最新记录(因此:0小时到2小时之间的一条记录,2小时到4小时之间的一条记录,依此类推)。注意,这并不一定意味着resultset中的记录之间有2小时的间隔。

在你的 demo on DB Fiddle ,查询将生成:

id_harga   | tgl_harga           |   harga | id_region
:--------- | :------------------ | ------: | :--------
HF01245523 | 2019-11-17 06:01:05 | 1.10513 | 599      
HF01245515 | 2019-11-17 05:59:07 | 1.10513 | 599      
HF01245035 | 2019-11-17 03:59:06 | 1.10513 | 599      
HF01244554 | 2019-11-17 01:57:06 | 1.10513 | 599      
HF01244082 | 2019-11-16 23:59:06 | 1.10513 | 599      
HF01243602 | 2019-11-16 21:59:06 | 1.10513 | 599      
HF01243114 | 2019-11-16 19:57:07 | 1.10513 | 599      
HF01242642 | 2019-11-16 17:59:06 | 1.10513 | 599      
HF01242162 | 2019-11-16 15:59:07 | 1.10513 | 599      
HF01241682 | 2019-11-16 13:59:06 | 1.10513 | 599      

列 campaign_code 不由子查询返回。另外,表别名 dmspro_mys_campaign_product 在外部查询中不可用,仅在子查询中可用。

您应该修改子查询,使其返回:

SELECT m.*, cp.campaign_code
FROM dmspro_mys_product_master m
INNER JOIN (
    SELECT DISTINCT product_id, campaign_code
    FROM dmspro_mys_campaign_product
) AS cp
ON cp.product_id = m.product_id

我还修正了对两个表使用表别名的查询:这缩短了查询并使其更可读。

如你所说,原始的先知 MERGE 语句只执行更新,不执行插入。

与oracle版本相比,mysql查询的一般语法看起来没有问题。以下是更新版本:

UPDATE table1 a
INNER JOIN table2 b 
    ON a.ROWID = b.ROWID 
    AND b.DATETIMEUTC >= 'formatter.form(dWV.getTime())'
SET a.THISIND = 'S'
WHERE 
    a.STATE = 'WV' 
    AND a.LAST_DTE = CURDATE()

变化:

• 当前日期可以通过函数获取 CURDATE()

• 'YYYY-MM-DD HH24:MI:SS' 是mysql日期的默认格式,因此不需要转换它,您可以按原样传递它(nb1:不清楚是什么 'formatter.form(dWV.getTime())' 实际上是指-nb2:如果你需要将字符串转换为日期, STR_TO_DATE 是你的朋友)

• 表上的筛选条件 a 最好放在 WHERE 条款,而桌子上的 b 最好是属于 INNER JOIN

有几种选择:

1)建立一系列 OR ED表达式如下:

SELECT t.* from mytable t WHERE t.name LIKE '%val1%' or t.name LIKE '%val2%'...

2)使用 find_in_set :可能比综合效率更高 LIKE S

SELECT t.* from mytable t WHERE find_in_set(t.name, 'val1,val2,...')

3)使用regexp:与 芬德尼集

SELECT t.* from mytable t WHERE t.name REGEXP 'val1|val2|...';

4)如果您有一个非常大的值列表,那么您的查询将变慢,并且您最终将在表示该列表的表达式中达到varchar的最大大小。我建议将它们填充到数据库表中,并使用 WHERE EXIST 具有相关子查询的条件:

SELECT t.*
FROM mytable t
WHERE EXISTS (SELECT 1 from mylist where t.name like CONCAT('%', l.val '%'))

5)使用MySQL 8,可以模拟列表表 with a CTE :

WITH mylist AS (
    SELECT '%val1%' UNION SELECT '%val2%' UNION ...)
)
SELECT t.*
FROM mytable t
WHERE EXISTS (SELECT 1 from mylist where t.name like CONCAT('%', l.val '%'))

你可以再加一个 LEFT JOIN 到表中链接的查询 users :

select rooms.room_name, groups.group_name, users.name 
from grouprooms 
left join rooms on grouprooms.room_ID = rooms.room_ID 
left join groups on grouprooms.group_ID = groups.group_ID
left join users on grouprooms.group_id = users.group_id

见 your updated db fiddle :

• 由于组3(操作)中没有用户,因此组6没有显示用户
• GroupRoom7未链接到组,因此它没有组名和用户

既然rdbms(mysql)有很好的内置功能,为什么还要在php中生成json呢?

您应该能够直接从数据库获得预期的输出,主要使用函数 JSON_OBJECT() (生成json对象)和 JSON_ARRAYAGG() (聚合json对象),可从mysql 5.7开始使用

首先,这里有一个查询,它生成当前获得的json输出(除了周围的 "kittens_data" 关键):

select json_arrayagg(
  json_object(
    'id', id,
    'type', type,
    'color', color,
    'cuteness', cuteness
  )
) AS js 
from users;

内心的呼唤 json_对象() 从输入记录和外部 json_arrayagg() 函数使用一个名为 js .

调整查询以获得预期的结果非常容易。我们首先需要 type ,然后在外部查询中再次聚合:

select json_arrayagg(js) js
from (
    select 
        json_object(
            'type', type,
            'box', json_arrayagg(json_object(id, 'id', color, 'color', cuteness, 'cuteness'))
        ) js
    from users
    group by type
) x;

Demo on DB Fiddle .

我认为 条件聚合 应该会成功的。可以通过以下方式过滤记录 name ,然后在聚合函数中应用逻辑。如果记录存在于 feature_code = 'RGN' 然后选择它,否则选择最小值 id 在匹配记录中。

SELECT IFNULL(MAX(CASE WHEN feature_code = 'RGN' THEN id END), MIN(id)) id_found
FROM mytable
WHERE name = @name;

Demo on DB Fiddle 搜索时 'Cornwall' :

| id_found |
| -------- |
| 11609029 |

注意:如果您想要整个匹配记录,一个解决方案是 JOIN 以上结果与原表一致:

SELECT t.*
FROM mytable t
INNER JOIN (
    SELECT IFNULL(MAX(CASE WHEN feature_code = 'RGN' THEN id END), MIN(id)) id_found
    FROM mytable
    WHERE name = @name
) x ON x.id_found = t.id;

Demo :

| id       | name     | admin1 | admin2 | admin3 | feature_class | feature_code |
| -------- | -------- | ------ | ------ | ------ | ------------- | ------------ |
| 11609029 | Cornwall | ENG    |        |        | L             | RGN          |

一 NOT EXISTS 带有相关子查询的condition可以做到这一点,比如:

SELECT *
FROM temp_laptimes t
WHERE NOT EXISTS (
    SELECT 1
    FROM temp_laptimes t1
    WHERE t1.lap_date < t.lap_date AND t1.laptime < t.laptime
)

这个 不存在 条件确保没有先前记录的圈数时间更短。

Demo on DB Fiddlde :

| lap_id | driver | laptime | lap_date   |
| ------ | ------ | ------- | ---------- |
| 1      | Dean   | 56.8    | 2019-01-01 |
| 33     | Carl   | 56.1    | 2019-03-01 |
| 61     | Bob    | 55.9    | 2019-06-01 |
| 84     | Anne   | 55.7    | 2019-08-01 |

如果您使用的是mysql 8.0,另一种可能更有效的方法是在子查询中使用窗口函数计算当前记录和正在处理的记录的最小圈时间。然后,外部查询筛选出最小值等于当前圈时间的记录:

SELECT *
FROM (
  SELECT 
      t.*, 
      MIN(laptime) OVER(ORDER BY lap_date) min_lap_time
  FROM temp_laptimes t
) x WHERE laptime = min_lap_time;

Demo on DB Fiddle (同样的结果)。

你好像在找 ROW_NUMBER() (在mysql 8.0中提供)。此窗口函数可用于在共享相同记录的组中对记录进行排序 user .

SELECT
    user,
    date,
    purchase_id,
    ROW_NUMBER() OVER(PARTITION BY user ORDER BY purchase_id ) purchase_order
FROM mytable

注:目前还不清楚您要使用哪一列来订购。它可能是 purchase_id (如上面的查询所示),或者 date :您可以根据需要更改查询。

Demo on DB Fiddle :

| user | date       | purchase_id | purchase_order |
| ---- | ---------- | ----------- | -------------- |
| a    | 2018-01-01 | 1           | 1              |
| a    | 2018-01-02 | 3           | 2              |
| a    | 2018-01-03 | 4           | 3              |
| a    | 2018-01-04 | 6           | 4              |
| b    | 2018-01-02 | 2           | 1              |
| b    | 2018-01-04 | 5           | 2              |

这应该可以做到:

SELECT
    id,
    CASE WHEN name IS NULL THEN 'NULL' ELSE 'Secret' END Name
FROM mytable

这个 demo on DB Fiddle 使用示例数据返回:

id | Name  
-: | :-----
 1 | Secret
 2 | NULL  
 3 | Secret

除了在 GROUP BY 子句,新查询中的逻辑似乎与旧查询中的逻辑不同(例如:子查询 q2 计算新内容…并且没有与其他表的联接条件)。

配置单元不支持中的子查询 SELECT 条款,但它 does allow them in FROM and WHERE clauses . 我只需将内联子查询移动到 从 条款。因为它只返回一条记录,所以 CROSS JOIN :

SELECT
    d.dept_name,
    de.dept_no,
    e.gender,
    (count(*)/x.cnt) AS Sex
FROM 
    employees e
    INNER JOIN dept_emp de ON de.emp_no =  e.emp_no
    INNER JOIN departments d ON de.dept_no = d.dept_no
    CROSS JOIN (SELECT COUNT(*) cnt FROM employees) x
GROUP BY 
    de.dept_no, 
    d.dept_name,
    e.gender
ORDER BY 
    de.dept_no;

NB1:总是使用 明确的 标准 JOIN 而不是旧的学校, 隐性的 加入 s;我相应地修改了查询(还添加了表别名)。