如何从 SQL 服务器中的 SELECT 进行更新？

Question

在SQL Server中，可以使用INSERT.. SELECT语句将行插入到表中：

INSERT INTO Table (col1, col2, col3)
SELECT col1, col2, col3 
FROM other_table 
WHERE sql = 'cool'

是否也可以使用SELECT更新表？ 我有一个包含这些值的临时表，我想使用这些值更新另一个表。 也许是这样的：

UPDATE Table SET col1, col2
SELECT col1, col2 
FROM other_table 
WHERE sql = 'cool'
WHERE Table.id = other_table.id

Answer 1

UPDATE
    Table_A
SET
    Table_A.col1 = Table_B.col1,
    Table_A.col2 = Table_B.col2
FROM
    Some_Table AS Table_A
    INNER JOIN Other_Table AS Table_B
        ON Table_A.id = Table_B.id
WHERE
    Table_A.col3 = 'cool'

Answer 2

在 SQL Server 2008（或更新版本）中，使用MERGE

MERGE INTO YourTable T
   USING other_table S 
      ON T.id = S.id
         AND S.tsql = 'cool'
WHEN MATCHED THEN
   UPDATE 
      SET col1 = S.col1, 
          col2 = S.col2;

或者：

MERGE INTO YourTable T
   USING (
          SELECT id, col1, col2 
            FROM other_table 
           WHERE tsql = 'cool'
         ) S
      ON T.id = S.id
WHEN MATCHED THEN
   UPDATE 
      SET col1 = S.col1, 
          col2 = S.col2;

Answer 3

UPDATE YourTable SET Col1 = OtherTable.Col1, Col2 = OtherTable.Col2 FROM ( SELECT ID, Col1, Col2 FROM other_table) AS OtherTable WHERE OtherTable.ID = YourTable.ID

Answer 4

我会修改罗宾对以下内容的出色回答：

UPDATE Table
SET Table.col1 = other_table.col1,
 Table.col2 = other_table.col2
FROM
    Table
INNER JOIN other_table ON Table.id = other_table.id
WHERE
    Table.col1 != other_table.col1
OR Table.col2 != other_table.col2
OR (
    other_table.col1 IS NOT NULL
    AND Table.col1 IS NULL
)
OR (
    other_table.col2 IS NOT NULL
    AND Table.col2 IS NULL
)

如果没有 WHERE 子句，您甚至会影响不需要受影响的行，这可能（可能）导致索引重新计算或触发真正不应该被触发的触发器。

Answer 5

单程

UPDATE t 
SET t.col1 = o.col1, 
    t.col2 = o.col2
FROM 
    other_table o 
  JOIN 
    t ON t.id = o.id
WHERE 
    o.sql = 'cool'

Answer 6

另一种尚未提及的可能性是将SELECT语句本身放入 CTE，然后更新 CTE。

;WITH CTE
     AS (SELECT T1.Col1,
                T2.Col1 AS _Col1,
                T1.Col2,
                T2.Col2 AS _Col2
         FROM   T1
                JOIN T2
                  ON T1.id = T2.id
         /*Where clause added to exclude rows that are the same in both tables
           Handles NULL values correctly*/
         WHERE EXISTS(SELECT T1.Col1,
                             T1.Col2
                       EXCEPT
                       SELECT T2.Col1,
                              T2.Col2))
UPDATE CTE
SET    Col1 = _Col1,
       Col2 = _Col2

这样做的好处是很容易首先自己运行SELECT语句来对结果进行完整性检查，但是如果它们在源表和目标表中命名相同，它确实需要您像上面一样为列设置别名。

这也与其他四个答案中显示的专有UPDATE ... FROM语法具有相同的限制。 如果源表位于一对多连接的多侧，那么在Update中将使用哪些可能匹配的连接记录是不确定的（如果有尝试， MERGE通过引发错误来避免这个问题多次更新同一行）。

Answer 7

为了记录（和其他人像我一样搜索），你可以在 MySQL 中这样做：

UPDATE first_table, second_table
SET first_table.color = second_table.color
WHERE first_table.id = second_table.foreign_id

Answer 8

使用别名：

UPDATE t
   SET t.col1 = o.col1
  FROM table1 AS t
         INNER JOIN 
       table2 AS o 
         ON t.id = o.id

Answer 9

简单的方法是：

UPDATE
    table_to_update,
    table_info
SET
    table_to_update.col1 = table_info.col1,
    table_to_update.col2 = table_info.col2

WHERE
    table_to_update.ID = table_info.ID

Answer 10

这可能是执行更新的一个小众原因（例如，主要用于过程中），或者对其他人来说可能是显而易见的，但还应该说明您可以在不使用 join 的情况下执行 update-select 语句（以防万一您正在更新的表没有公共字段）。

update
    Table
set
    Table.example = a.value
from
    TableExample a
where
    Table.field = *key value* -- finds the row in Table 
    AND a.field = *key value* -- finds the row in TableExample a

Answer 11

这是另一个有用的语法：

UPDATE suppliers
SET supplier_name = (SELECT customers.name
                     FROM customers
                     WHERE customers.customer_id = suppliers.supplier_id)
WHERE EXISTS (SELECT customers.name
              FROM customers
              WHERE customers.customer_id = suppliers.supplier_id);

它通过使用“WHERE EXIST”检查它是否为空。

Answer 12

我添加它只是为了让您可以看到一种快速编写它的方法，以便您可以在进行更新之前检查将要更新的内容。

UPDATE Table 
SET  Table.col1 = other_table.col1,
     Table.col2 = other_table.col2 
--select Table.col1, other_table.col,Table.col2,other_table.col2, *   
FROM     Table 
INNER JOIN     other_table 
    ON     Table.id = other_table.id

Answer 13

如果您使用MySQL而不是 SQL Server，则语法为：

UPDATE Table1
INNER JOIN Table2
ON Table1.id = Table2.id
SET Table1.col1 = Table2.col1,
    Table1.col2 = Table2.col2

Answer 14

在 SQL 数据库中使用 INNER JOIN 从 SELECT 更新

由于这篇文章的回复太多，投票率最高，我想我也在这里提供我的建议。 虽然这个问题很有趣，但我在很多论坛网站上看到过，并使用INNER JOIN并附有截图做出了解决方案。

首先，我创建了一个以schoolold命名的表，并插入了一些关于它们的列名的记录并执行它。

然后我执行SELECT命令来查看插入的记录。

然后我创建了一个以schoolnew命名的新表，并在上面类似地执行了上面的操作。

然后，为了查看其中插入的记录，我执行 SELECT 命令。

现在，我想在这里对第三行和第四行进行一些更改，以完成此操作，我使用INNER JOIN执行UPDATE命令。

要查看更改，我执行SELECT命令。

你可以看到表schoolold的第三和第四的记录轻松地通过使用INNER JOIN与UPDATE语句表schoolnew取代。

Answer 15

如果你想自己加入表格（这不会经常发生）：

update t1                    -- just reference table alias here
set t1.somevalue = t2.somevalue
from table1 t1               -- these rows will be the targets
inner join table1 t2         -- these rows will be used as source
on ..................        -- the join clause is whatever suits you

Answer 16

通过CTE更新比这里的其他答案更具可读性：

;WITH cte
     AS (SELECT col1,col2,id
         FROM   other_table
         WHERE  sql = 'cool')
UPDATE A
SET    A.col1 = B.col1,
       A.col2 = B.col2
FROM   table A
       INNER JOIN cte B
               ON A.id = B.id

Answer 17

以下示例使用派生表（FROM 子句后的 SELECT 语句）返回旧值和新值以进行进一步更新：

UPDATE x
SET    x.col1 = x.newCol1,
       x.col2 = x.newCol2
FROM   (SELECT t.col1,
               t2.col1 AS newCol1,
               t.col2,
               t2.col2 AS newCol2
        FROM   [table] t
               JOIN other_table t2
                 ON t.ID = t2.ID) x

Answer 18

如果您使用的是 SQL Server，则可以在不指定联接的情况下从另一个表更新一个表，只需从where子句链接这两个表即可。 这使得一个更简单的 SQL 查询：

UPDATE Table1
SET Table1.col1 = Table2.col1,
    Table1.col2 = Table2.col2
FROM
    Table2
WHERE
    Table1.id = Table2.id

Answer 19

在这里整合所有不同的方法。

选择更新
使用公用表表达式更新
合并

示例表结构如下，将从 Product_BAK 更新为 Product 表。

产品

CREATE TABLE [dbo].[Product](
    [Id] [int] IDENTITY(1, 1) NOT NULL,
    [Name] [nvarchar](100) NOT NULL,
    [Description] [nvarchar](100) NULL
) ON [PRIMARY]

产品_比克

    CREATE TABLE [dbo].[Product_BAK](
        [Id] [int] IDENTITY(1, 1) NOT NULL,
        [Name] [nvarchar](100) NOT NULL,
        [Description] [nvarchar](100) NULL
    ) ON [PRIMARY]

1. 选择更新

    update P1
    set Name = P2.Name
    from Product P1
    inner join Product_Bak P2 on p1.id = P2.id
    where p1.id = 2

2. 用公用表表达式更新

    ; With CTE as
    (
        select id, name from Product_Bak where id = 2
    )
    update P
    set Name = P2.name
    from  product P  inner join CTE P2 on P.id = P2.id
    where P2.id = 2

3. 合并

    Merge into product P1
    using Product_Bak P2 on P1.id = P2.id

    when matched then
    update set p1.[description] = p2.[description], p1.name = P2.Name;

在这个 Merge 语句中，如果在目标中没有找到匹配的记录，但在源中存在并且请找到语法，我们可以做 inset：

    Merge into product P1
    using Product_Bak P2 on P1.id = P2.id;

    when matched then
    update set p1.[description] = p2.[description], p1.name = P2.Name;

    WHEN NOT MATCHED THEN
    insert (name, description)
    values(p2.name, P2.description);

Answer 20

另一种方法是使用派生表：

UPDATE t
SET t.col1 = a.col1
    ,t.col2 = a.col2
FROM (
SELECT id, col1, col2 FROM @tbl2) a
INNER JOIN @tbl1 t ON t.id = a.id

样本数据

DECLARE @tbl1 TABLE (id INT, col1 VARCHAR(10), col2 VARCHAR(10))
DECLARE @tbl2 TABLE (id INT, col1 VARCHAR(10), col2 VARCHAR(10))

INSERT @tbl1 SELECT 1, 'a', 'b' UNION SELECT 2, 'b', 'c'

INSERT @tbl2 SELECT 1, '1', '2' UNION SELECT 2, '3', '4'

UPDATE t
SET t.col1 = a.col1
    ,t.col2 = a.col2
FROM (
SELECT id, col1, col2 FROM @tbl2) a
INNER JOIN @tbl1 t ON t.id = a.id

SELECT * FROM @tbl1
SELECT * FROM @tbl2

Answer 21

UPDATE TQ
SET TQ.IsProcessed = 1, TQ.TextName = 'bla bla bla'
FROM TableQueue TQ
INNER JOIN TableComment TC ON TC.ID = TQ.TCID
WHERE TQ.IsProcessed = 0

为确保您正在更新您想要的内容，请先选择

SELECT TQ.IsProcessed, 1 AS NewValue1, TQ.TextName, 'bla bla bla' AS NewValue2
FROM TableQueue TQ
INNER JOIN TableComment TC ON TC.ID = TQ.TCID
WHERE TQ.IsProcessed = 0

Answer 22

甚至还有一种更短的方法，您可能会感到惊讶：

样本数据集：

CREATE TABLE #SOURCE ([ID] INT, [Desc] VARCHAR(10));
CREATE TABLE #DEST   ([ID] INT, [Desc] VARCHAR(10));

INSERT INTO #SOURCE VALUES(1,'Desc_1'), (2, 'Desc_2'), (3, 'Desc_3');
INSERT INTO #DEST   VALUES(1,'Desc_4'), (2, 'Desc_5'), (3, 'Desc_6');

代码：

UPDATE #DEST
SET #DEST.[Desc] = #SOURCE.[Desc]
FROM #SOURCE
WHERE #DEST.[ID] = #SOURCE.[ID];

Answer 23

用：

drop table uno
drop table dos

create table uno
(
    uid int,
    col1 char(1),
    col2 char(2)
)
create table dos
(
    did int,
    col1 char(1),
    col2 char(2),
    [sql] char(4)
)
insert into uno(uid) values (1)
insert into uno(uid) values (2)
insert into dos values (1,'a','b',null)
insert into dos values (2,'c','d','cool')

select * from uno 
select * from dos

任何一个：

update uno set col1 = (select col1 from dos where uid = did and [sql]='cool'), 
col2 = (select col2 from dos where uid = did and [sql]='cool')

或者：

update uno set col1=d.col1,col2=d.col2 from uno 
inner join dos d on uid=did where [sql]='cool'

select * from uno 
select * from dos

如果两个表中的 ID 列名称相同，则只需将表名称放在要更新的表之前，并为所选表使用别名，即：

update uno set col1 = (select col1 from dos d where uno.[id] = d.[id] and [sql]='cool'),
col2  = (select col2 from dos d where uno.[id] = d.[id] and [sql]='cool')

Answer 24

在接受的答案中，在：

SET
Table_A.col1 = Table_B.col1,
Table_A.col2 = Table_B.col2

我会补充：

OUTPUT deleted.*, inserted.*

我通常做的是将所有内容放入回滚事务中并使用"OUTPUT" ：通过这种方式，我可以看到即将发生的一切。 当我对所看到的感到满意时，我将ROLLBACK更改为COMMIT 。

我通常需要记录我所做的事情，所以我在运行回滚查询时使用"results to Text"选项，并保存脚本和 OUTPUT 的结果。 （当然，如果我更改了太多行，这是不切实际的）

Answer 25

以下解决方案适用于 MySQL 数据库：

UPDATE table1 a , table2 b 
SET a.columname = 'some value' 
WHERE b.columnname IS NULL ;

Answer 26

UPDATE table AS a
INNER JOIN table2 AS b
ON a.col1 = b.col1
INNER JOIN ... AS ...
ON ... = ...
SET ...
WHERE ...

Answer 27

从 select 语句更新的另一种方法：

UPDATE A
SET A.col = A.col,B.col1 = B.col1
FROM  first_Table AS A
INNER JOIN second_Table AS B  ON A.id = B.id WHERE A.col2 = 'cool'

Answer 28

选项 1：使用内部联接：

UPDATE
    A
SET
    A.col1 = B.col1,
    A.col2 = B.col2
FROM
    Some_Table AS A
    INNER JOIN Other_Table AS B
        ON A.id = B.id
WHERE
    A.col3 = 'cool'

选项 2：相关的子查询

UPDATE table 
SET Col1 = B.Col1, 
    Col2 = B.Col2 
FROM (
    SELECT ID, Col1, Col2 
    FROM other_table) B
WHERE 
    B.ID = table.ID

Answer 29

重要的是要指出，就像其他人一样， MySQL或MariaDB使用不同的语法。 它还支持非常方便的 USING 语法（与 T/SQL 相比）。 INNER JOIN 也是 JOIN 的同义词。 因此，原始问题中的查询最好在 MySQL 中实现：

UPDATE
    Some_Table AS Table_A

JOIN
    Other_Table AS Table_B USING(id)

SET
    Table_A.col1 = Table_B.col1,
    Table_A.col2 = Table_B.col2

WHERE
    Table_A.col3 = 'cool'

我还没有在其他答案中看到所问问题的解决方案，因此我花了两美分。 （在 PHP 7.4.0 MariaDB 10.4.10 上测试）

Answer 30

UPDATE table1
SET column1 = (SELECT expression1
               FROM table2
               WHERE conditions)
[WHERE conditions];

使用 SQL Server 中另一个表中的数据更新一个表时 UPDATE 语句的语法

Answer 31

您可以从此在 sql server 中使用更新

UPDATE
    T1
SET
   T1.col1 = T2.col1,
   T1.col2 = T2.col2
FROM
   Table1 AS T1
INNER JOIN Table2 AS T2
    ON T1.id = T2.id
WHERE
    T1.col3 = 'cool'

Answer 32

declare @tblStudent table (id int,name varchar(300))
declare @tblMarks table (std_id int,std_name varchar(300),subject varchar(50),marks int)

insert into @tblStudent Values (1,'Abdul')
insert into @tblStudent Values(2,'Rahim')

insert into @tblMarks Values(1,'','Math',50)
insert into @tblMarks Values(1,'','History',40)
insert into @tblMarks Values(2,'','Math',30)
insert into @tblMarks Values(2,'','history',80)


select * from @tblMarks

update m
set m.std_name=s.name
 from @tblMarks as m
left join @tblStudent as s on s.id=m.std_id

select * from @tblMarks

Answer 33

我之前使用过 INSERT SELECT。 对于那些想在这里使用新东西的人来说，这是一个类似的解决方案，但它要短得多：

UPDATE table1                                          // Table that's going to be updated.
LEFT JOIN                                              // Type of join.
    table2 AS tb2                                      // Second table and rename for easy.
ON
    tb2.filedToMatchTables = table1.fieldToMatchTables // Fields to connect both tables.
SET
    fieldFromTable1 = tb2.fieldFromTable2;             // Field to be updated on table1.

    field1FromTable1 = tb2.field1FromTable2,           // This is in the case you need to
    field1FromTable1 = tb2.field1FromTable2,           // update more than one field.
    field1FromTable1 = tb2.field1FromTable2;           // Remember to put ; at the end.

Answer 34

可以以稍微不同的方式编写相同的解决方案，因为我只想在写完两个表后才设置列。 在mysql中工作。

UPDATE Table t, 
(SELECT col1, col2 FROM other_table WHERE sql = 'cool' ) o
SET t.col1 = o.col1, t.col2=o.col2
WHERE t.id = o.id

Answer 35

使用 SQLite3 对我来说效果很好，在 INNER SELECT 之后用 SELECT 更新行。

UPDATE clients
SET col1 = '2023-02-02 18:51:30.826621'
FROM (
      SELECT * FROM clients dc WHERE dc.phone NOT IN (
               SELECT do.phone FROM dclient_order do WHERE do.order_date > '2023-01-01' GROUP BY do.phone
               )
      ) NewTable
WHERE clients.phone = NewTable.phone;

Answer 36

最佳实践在公司使用的 SQL Server 中更新行和安全<\/strong>

 WITH t AS 
         (
           SELECT UserID, EmailAddress, Password, Gender, DOB, Location, 
           Active  FROM Facebook.Users
         )
 UPDATE t SET Active = 0

Answer 37

像这样; 但是你必须确保更新表和表之后的表是相同的。

UPDATE Table SET col1, col2
FROM table
inner join other_table Table.id = other_table.id
WHERE sql = 'cool'

Answer 38

Oracle SQL（使用别名）：

UPDATE Table T 
SET T.col1 = (SELECT OT.col1 WHERE OT.id = T.id),
T.col2 = (SELECT OT.col2 WHERE OT.id = T.id);

如何从 SQL 服务器中的 SELECT 进行更新？

问题描述

38 个解决方案

解决方案1 5719 已采纳 2010-02-25 14:39:55

解决方案2 829 2011-09-09 09:40:21

解决方案3 755 2012-01-22 17:47:09

解决方案4 298 2011-09-08 21:20:00

解决方案5 219 2010-02-25 14:41:40

解决方案6 181 2011-11-06 00:18:38

解决方案7 131 2012-10-05 14:20:32

解决方案8 106 2012-05-23 13:06:56

解决方案9 82 2012-11-14 13:17:40

解决方案10 69 2012-06-11 16:58:24

解决方案11 64 2013-05-02 09:48:30

解决方案12 59 2011-09-08 21:35:34

解决方案13 57 2013-10-03 13:16:44

解决方案14 56 2015-11-30 05:48:56

解决方案15 48 2014-06-27 21:14:53

解决方案16 45 2015-12-12 16:32:39

解决方案17 44 2013-09-25 06:18:13

解决方案18 43 2017-02-20 16:34:56

解决方案19 29 2018-01-31 15:42:41

产品

产品_比克

1. 选择更新

2. 用公用表表达式更新

3. 合并

解决方案20 25 2016-02-24 23:35:12

解决方案21 25 2016-11-30 21:06:38

解决方案22 24 2017-01-26 13:28:32

解决方案23 22 2014-06-18 11:40:19

解决方案24 16 2017-04-27 07:54:50

解决方案25 14 2014-10-01 06:24:34

解决方案26 14 2015-07-31 08:04:59

解决方案27 13 2016-09-08 12:02:24

解决方案28 10 2018-11-07 07:34:07

解决方案29 8 2020-06-10 11:43:29

解决方案30 7 2019-03-14 07:00:19

解决方案31 2 2018-08-31 16:48:35

解决方案32 2 2018-10-08 12:22:18

解决方案33 1 2020-04-09 03:30:39

解决方案34 0 2018-11-22 06:09:06

解决方案35 0 2023-02-02 16:59:00

解决方案36 -1 2021-09-27 03:31:49

解决方案37 -3 2018-11-22 06:54:34

解决方案38 -4 2022-02-22 08:14:11

解决方案1
5719 已采纳 2010-02-25 14:39:55

解决方案2
829 2011-09-09 09:40:21

解决方案3
755 2012-01-22 17:47:09

解决方案4
298 2011-09-08 21:20:00

解决方案5
219 2010-02-25 14:41:40

解决方案6
181 2011-11-06 00:18:38

解决方案7
131 2012-10-05 14:20:32

解决方案8
106 2012-05-23 13:06:56

解决方案9
82 2012-11-14 13:17:40

解决方案10
69 2012-06-11 16:58:24

解决方案11
64 2013-05-02 09:48:30

解决方案12
59 2011-09-08 21:35:34

解决方案13
57 2013-10-03 13:16:44

解决方案14
56 2015-11-30 05:48:56

解决方案15
48 2014-06-27 21:14:53

解决方案16
45 2015-12-12 16:32:39

解决方案17
44 2013-09-25 06:18:13

解决方案18
43 2017-02-20 16:34:56

解决方案19
29 2018-01-31 15:42:41

解决方案20
25 2016-02-24 23:35:12

解决方案21
25 2016-11-30 21:06:38

解决方案22
24 2017-01-26 13:28:32

解决方案23
22 2014-06-18 11:40:19

解决方案24
16 2017-04-27 07:54:50

解决方案25
14 2014-10-01 06:24:34

解决方案26
14 2015-07-31 08:04:59

解决方案27
13 2016-09-08 12:02:24

解决方案28
10 2018-11-07 07:34:07

解决方案29
8 2020-06-10 11:43:29

解决方案30
7 2019-03-14 07:00:19

解决方案31
2 2018-08-31 16:48:35

解决方案32
2 2018-10-08 12:22:18

解决方案33
1 2020-04-09 03:30:39

解决方案34
0 2018-11-22 06:09:06

解决方案35
0 2023-02-02 16:59:00

解决方案36
-1 2021-09-27 03:31:49

解决方案37
-3 2018-11-22 06:54:34

解决方案38
-4 2022-02-22 08:14:11