关于sql：您无法在FROM子句中指定要更新的目标表

You can't specify target table for update in FROM clause

我有一个简单的mysql表：

1
2
3
4
5
6
7
8
9
10
11
12

CREATE TABLE IF NOT EXISTS `pers` (
`persID` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(35) NOT NULL,
`gehalt` INT(11) NOT NULL,
`chefID` INT(11) DEFAULT NULL,
PRIMARY KEY (`persID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=4 ;

INSERT INTO `pers` (`persID`, `name`, `gehalt`, `chefID`) VALUES
(1, 'blb', 1000, 3),
(2, 'as', 1000, 3),
(3, 'chef', 1040, NULL);

我试图运行以下更新，但我只得到错误1093：

1
2
3
4
5
6
7
8
9
10

UPDATE pers P
SET P.gehalt=P.gehalt * 1.05
WHERE (P.chefID IS NOT NULL
OR gehalt <
(SELECT (
SELECT MAX(gehalt * 1.05)
FROM pers MA
WHERE MA.chefID = MA.chefID)
AS _pers
))

我搜索了错误，并在http://dev.mysql.com/doc/refman/5.1/en/subquery-restrictions.html页面的mysql中找到，但它对我没有帮助。

我该怎么做才能纠正sql查询？

相关讨论

问题在于，无论出于什么原因，MySQL都不允许你编写这样的查询：

1
2
3
4
5
6
7

UPDATE myTable
SET myTable.A =
(
SELECT B
FROM myTable
INNER JOIN ...
)

也就是说，如果您在表上执行UPDATE / INSERT / DELETE，则无法在内部查询中引用该表(但您可以从该外部表中引用该字段...)

解决方案是用(SELECT * FROM myTable)替换子查询中的myTable实例，就像这样

1
2
3
4
5
6
7

UPDATE myTable
SET myTable.A =
(
SELECT B
FROM (SELECT * FROM myTable) AS something
INNER JOIN ...
)

这显然会导致必要的字段被隐式复制到临时表中，所以它是允许的。

我在这里找到了解决方案。该文的说明：

You don’t want to just SELECT * FROM table in the subquery in real life; I just wanted to keep the examples simple. In reality, you should only be selecting the columns you need in that innermost query, and adding a good WHERE clause to limit the results, too.

相关讨论

我认为原因并不是真的。想想语义。 MySQL必须在更新开始之前保留表的副本，否则内部查询可能会使用已在查询过程中更新的数据。这些副作用都不一定是理想的，所以最安全的做法是强迫你指定使用额外表格会发生什么。
@siride：其他数据库，如MSSQL或Oracle，没有这种任意限制
@ BlueRaja-DannyPflughoeft：这不是随意的。这是基于替代品成本的合理设计决策。其他数据库系统无论如何都选择处理这些成本。但是，例如，当您使用GROUP BY时，这些系统不允许您在SELECT列表中包含非聚合列，而MySQL则使用GROUP聚合列。我认为MySQL在这里是错误的，我可能会说UPDATE语句的其他DBMS也是如此。
你必须和@CSchulz谈谈:)
我的天啊！你节省了我的一天！非常感谢！在存储过程中的DELETE查询中发生了同样的事情。
@DarkSide的答案比这更好，应该被标记为已接受的答案 - 他正在做同样的事情，但避免了做INNER JOIN的麻烦，这是不需要的，也不是原来的问题。
@siride从关系代数的角度来看，T和(SELECT * FROM T)是完全等价的。它们是相同的关系。因此，这是一种任意的，无限制的限制。更具体地说，它是一种解决方法，可以强迫MySQL做一些它显然可以做的事情，但由于某些原因它无法以更简单的形式解析。
@Tobia：你错过了为什么第二个版本有效的解释，它与学术关系代数和实现无关(这在现实世界中是必需的，在这个世界中，事物不能理论上发生，但必须实际发生)。如果有临时表，则避免了不一致问题。 MySQL可以选择始终使用临时表，或者跟踪哪些行已更新以避免在子查询中包含更新的值，但这是额外的复杂性，设计人员选择避免它。这是一个合理的权衡。
@Tobia：对于记录，SQL Server在所有情况下都正确地假脱机表数据，所以它没有这个限制。
我可以确认这是按预期工作的，并且是解决问题的最明智的方法。谢谢！
在运行h2数据库时，即使在mySQL兼容性方面，他们也不会接受这个问题。
请注意，从MySQL 5.7.6开始，优化器可以优化子查询并仍然给你错误，除非你SET optimizer_switch = 'derived_merge=off'; :-(
没有理由，这完全是巧合，当你在2016-02-18 20：18：50Z编辑答案时，我正坐在这个页面上阅读你的答案。它自2013年以来没有被编辑过。哇。
在我的情况下，接受的解决方案不起作用，因为我的桌子太大了。查询从未完成。显然这需要太多的内部资源。相反，我使用内部查询创建了一个View，并将其用于数据选择，这非常合适。 DELETE FROM t WHERE tableID NOT IN (SELECT viewID FROM t_view);我还建议之后运行OPTIMIZE TABLE t;以减小表的大小。
这会是原子的吗？在select和insert之间，您可能有另一个查询更改您选择的值，您可能会得到奇怪的结果。这样做时你需要读取锁定表，不是吗？
@EvrenYurtesen：不，这是一个单一的查询，在任何事务数据库中都应该是原子的(尽管注意，特别是使用MyISAM的MySQL不是事务性的。你应该使用InnoDB)
@ BlueRaja-DannyPflughoeft你有这个文档的链接？因为UPDATE查询可能是原子的，但如果2个线程使用子查询运行更新，我不相信子查询是否不会同时运行。
@EvrenYurtesen：请参阅有关事务隔离级别的文档。如果DB无法正确处理该情况，则不能满足ACID的隔离原则。我认为你大大低估了数据库的复杂性和强大性。
实际上你指出的文件说的是相反的。它说，默认情况下mysql支持可重复读取，一旦事务开始，它将不会看到另一个线程所做的更新。因此，如果同时启动两个更新语句，则会出现问题，这会更新子查询中选定的列。因为您希望一个查询更新字段，所以第二个查询使用更新的字段。但他们都会使用相同的旧字段，因为它们都同时启动了事务。
这导致绝对令人难以置信的性能非常完美哇(谢谢你节省我的一天顺便说一句)
@CodeX解决方案可以创建一个VIEW
问题是，如果表很大，执行(select * from table)与常规连接和WHERE子句，这将返回整个表，然后应用您的过滤器。在制作大型应用程序时，这是一个巨大的交易。在MSSQL Server下，我没有问题。但我现在正在使用MySQL。这让我很生气......
感谢您解释为何需要该表的副本。但是，mysql中的查询性能很差，执行速度非常慢。

您可以分三步完成：

1
2
3
4
5
6
7
8
9
10
11
12
13

CREATE TABLE test2 AS
SELECT PersId
FROM pers p
WHERE (
chefID IS NOT NULL
OR gehalt < (
SELECT MAX (
gehalt * 1.05
)
FROM pers MA
WHERE MA.chefID = p.chefID
)
)

...

1
2
3
4
5
6
7
8

UPDATE pers P
SET P.gehalt=P.gehalt * 1.05
WHERE PersId
IN (
SELECT PersId
FROM test2
)
DROP TABLE test2;

要么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

UPDATE Pers P, (
SELECT PersId
FROM pers p
WHERE (
chefID IS NOT NULL
OR gehalt < (
SELECT MAX (
gehalt * 1.05
)
FROM pers MA
WHERE MA.chefID = p.chefID
)
)
) t
SET P.gehalt=P.gehalt * 1.05
WHERE p.PersId = t.PersId

相关讨论

在Mysql中，您不能通过子查询同一个表来更新一个表。

您可以将查询分为两部分，或者执行

1
2
3

UPDATE TABLE_A AS A
INNER JOIN TABLE_A AS B ON A.field1 = B.field1
SET field2 = ?

相关讨论

从子查询创建临时表(tempP)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

UPDATE pers P
SET P.gehalt=P.gehalt * 1.05
WHERE P.persID IN (
SELECT tempP.tempId
FROM (
SELECT persID AS tempId
FROM pers P
WHERE
P.chefID IS NOT NULL OR gehalt <
(SELECT (
SELECT MAX(gehalt * 1.05)
FROM pers MA
WHERE MA.chefID = MA.chefID)
AS _pers
)
) AS tempP
)

我已经引入了一个单独的名称(别名)，并为临时表的'persID'列提供了一个新名称

相关讨论

这很简单。例如，而不是写：

1
2
3
4
5

INSERT INTO x (id, parent_id, code) VALUES (
NULL,
(SELECT id FROM x WHERE code='AAA'),
'BBB'
);

你应该写

1
2
3
4
5
6

INSERT INTO x (id, parent_id, code)
VALUES (
NULL,
(SELECT t.id FROM (SELECT id, code FROM x) t WHERE t.code='AAA'),
'BBB'
);

或类似的。

BlueRaja发布的方法很慢我将其修改为
我用来删除表中的重复项。万一它可以帮助任何人拥有大桌子
原始查询

1	DELETE FROM TABLE WHERE id NOT IN (SELECT MIN(id) FROM TABLE GROUP BY FIELD 2)

这需要更多时间：

1 2	DELETE FROM TABLE WHERE ID NOT IN( SELECT MIN(t.Id) FROM (SELECT Id,field2 FROM TABLE) AS t GROUP BY field2)

更快的解决方案

1 2	DELETE FROM TABLE WHERE ID NOT IN( SELECT x.Id FROM (SELECT MIN(Id) AS Id FROM TABLE GROUP BY field2) AS t)

作为参考，您也可以使用Mysql变量来保存临时结果，例如：

1 2	SET @v1 := (SELECT ... ); UPDATE ... SET ... WHERE x=@v1;

https://dev.mysql.com/doc/refman/5.7/en/user-variables.html

如果您尝试从tableA读取fieldA并将其保存在同一个表的fieldB上，则当fieldc = fieldd时，您可能需要考虑这一点。

1
2
3
4
5
6
7

UPDATE tableA,
tableA AS tableA_1
SET
tableA.fieldB= tableA_1.filedA
WHERE
(((tableA.conditionFild) = 'condition')
AND ((tableA.fieldc) = tableA_1.fieldd));

当条件字段满足您的条件时，上面的代码将fieldA中的值复制到fieldB。这也适用于ADO(例如访问)

来源：试过自己

MariaDB从10.3.x(DELETE和UPDATE)开始提升了这一点：

UPDATE - Statements With the Same Source and Target

From MariaDB 10.3.2, UPDATE statements may have the same source and target.

Until MariaDB 10.3.1, the following UPDATE statement would not work:

1
2
3
UPDATE t1 SET c1=c1+1 WHERE c2=(SELECT MAX(c2) FROM t1);
ERROR 1093 (HY000): TABLE 't1' IS specified twice,
BOTH AS a target FOR 'UPDATE' AND AS a separate SOURCE FOR DATA

From MariaDB 10.3.2, the statement executes successfully:

1
UPDATE t1 SET c1=c1+1 WHERE c2=(SELECT MAX(c2) FROM t1);

DELETE - Same Source and Target Table

Until MariaDB 10.3.1, deleting from a table with the same source and target was not possible. From MariaDB 10.3.1, this is now possible. For example:

1
DELETE FROM t1 WHERE c1 IN (SELECT b.c1 FROM t1 b WHERE b.c2=0);

DBFiddle MariaDB 10.2 - 错误

DBFiddle MariaDB 10.3 - 成功

update x set available_material_id = null其中id不在(从x中选择id，其中additional_info = 1);

1
2
3
4
5
6

-- use left join ----
UPDATE x LEFT JOIN
x xx
ON x.id = xx.id AND xx.additional_info = 1
SET available_material_id = NULL
WHERE xx.id IS NULL;