标签: update

foo在具有两列（id和）的表中seq，我想为seq具有任意 . 的所有记录添加+1 seq > 4738。计划是在seq=4739所有seq > 4738记录移动+1 后立即插入一条新记录。

这是桌子。

CREATE TABLE foo
(
  id uuid NOT NULL,
  seq integer NOT NULL,
  CONSTRAINT seq_key UNIQUE (seq)
)

CREATE UNIQUE INDEX idx_id
  ON foo
  USING btree
  (id);

CREATE UNIQUE INDEX idx_seq
  ON foo
  USING btree
  (seq);

我尝试通过以下查询实现 +1 转变。请注意，我使用子查询尝试> 4738按降序更新记录（即假设 max seq=10000，则首先更新最后一条记录（10000->10001），然后更新倒数第二条记录（seq=10000此时不存在，seq=9999-> seq=10000（没有违反约束），然后是 9998 -> 9999，...以避免在任何时候发生唯一的约束违反。但是，这假设更新查询是顺序执行的，而这似乎并不是发生的情况。

跑步时

UPDATE foo SET seq=anon_1.new_seq FROM …

CREATE TABLE widget (
  id serial PRIMARY KEY,
  name text NOT NULL,
  ordinal int NOT NULL UNIQUE
);

我有数据

 id | name | ordinal 
----+------+---------
  1 | A    |       1
  2 | B    |       2
  3 | C    |       3

我想将其更新为

 id | name | ordinal 
----+------+---------
  1 | A    |       3
  2 | B    |       2
  3 | C    |       1

尽可能少地接触记录（即不要重写整个记录集，不要启动不必要的触发器），更新为ordinal目标值的通用方法是什么？

普通更新只会给我带来约束违规，即使它发生在单个语句中。

删除并重新创建唯一约束的成本很高，而且并发性很差。

这似乎是一个很常见的问题，应该有一个好的方法来做到这一点，但我只是想不出。

我们维护一个用 PostgreSQL 和 python 实现的大型数据仓库。我们所做的一种非常常见的模式是进行更新插入，并在更新时进行记录。我们有一些独特的键my_key和值，例如my_uuid, my_text, my_int, my_date。如果给定的任何这些值发生变化，my_key我们希望更新该行。没关系，我们有一个运行良好的模式：

insert into my_table (
    my_key,
    my_uuid,
    my_text,
    my_int,
    my_date
)
select
    some_key,
    some_uuid,
    some_text,
    some_int,
    some_date
from some_table
on conflict (my_key) do update set
    some_uuid = excluded.some_uuid,
    some_text = excluded.some_text,
    some_int = excluded.some_int,
    some_date = excluded.some_date,
    update_timestamp = now()
where 
    coalesce(my_table.some_uuid, uuid_nil()) <> coalesce(excluded.some_uuid, uuid_nil())
    or coalesce(my_table.some_text, '') <> coalesce(excluded.some_text, '')
    or coalesce(my_table.some_int, -1) <> coalesce(excluded.some_int, -1)
    or coalesce(my_table.some_date, '3000-01-01'::date) <> coalesce(excluded.some_date, '3000-01-01'::date)

最后一个on conflict …

设想：

我正在运行一个连接到 SQL Server 作为数据后端的用户应用程序。\n在正常的一天中，与应用程序关联的表中的数据可能会频繁更改，目前保存着 1500 万多条记录（并且还在进一步增长） 。但是，只有在整个更新语句成功完成后，应用程序才能应用和访问插入和更新插入，并且永远不会发生脏读。

为了能够为应用程序提供对表的持续可访问性，我使用了一个辅助表，在其中进行实际更新和索引重建，以便主表保持解锁状态。完成后，表就被交换了。

我还调查了：

\n
• 启用读取已提交快照（不过，它似乎相当消耗资源）
\n
• 使用水平分区
\n

问题：

由于我对此相当陌生，并且不太确定是否有任何“更好”的方法来解决这种情况（性能、数据库本机、设置方面等），因此值得深思。

更新：

\n
• App\xc2\xb4s 营业时间为 9 点到 5 点
\n
• Azure 上托管的 SQL Server Enterprise (AzureSQL)
\n

今天我正在阅读一些很久以前做的数据库笔记。我看到了这个查询：

UPDATE Sales.Orders
SET (shipcountry, shipregion, shipcity)=
(SELECT country, region, city
FROM Sales.Customers AS C
WHERE C.custid =Sales.Orders.custid)
WHERE custid IN
(SELECT custid FROM Sales.Customers WHERE country = 'USA');

我对这个语法真的很陌生。但我的注释说它是“有效的 SQL Server 更新语法”。这是真的？SSMS 无法解析它。当我尝试运行它时，我得到了这个：

另外，SQL Server 的UPDATE文档似乎建议在关键字(之后不允许使用SET。无论如何，我只是想确认一下。

我使用 PostgreSQL 和以下数据库架构：

CREATE TABLE plans (
    slug VARCHAR(500) PRIMARY KEY
);

CREATE TABLE users (
    id VARCHAR(16) PRIMARY KEY,
    org_id VARCHAR(16) NOT NULL
);

CREATE TABLE orgs (
    id VARCHAR(16) PRIMARY KEY,
    plan_slug VARCHAR(500) NOT NULL,
    last_write_at DOUBLE PRECISION
);

就我而言，我想编写一个查询来更新某些组织plan_slug并保护它免受其他可能的并发更新的影响。为此，我SELECT在子查询中使用 a 并按FOR UPDATE特定顺序锁定行以避免死锁。就像下面的查询一样：

UPDATE orgs
SET plan_slug = 'plan_1'
WHERE id = ANY(
    SELECT subquery_orgs.id
    FROM orgs AS subquery_orgs
    JOIN users ON users.org_id = subquery_orgs.id
    WHERE users.id = ANY('{user_1, user_2, user_3}')
    ORDER …

我正在努力寻找将一些“varchar”列迁移到“nvarchar”的最佳方法。我使用的选项之一是添加新的 nvarchar 列，然后更新原始列中的值，删除原始列并将新列重命名为旧名称。

我知道它会生成大量的UNDO和REDO数据。不过，我还有其他限制（主要是 SQL Server 不支持并行 DDL 和多列 ALTER 表操作），因此让我们关注如何更快地运行更新语句。

我的 Oracle 经验告诉我使用内部并行性，但是它在 SQL Server 中可用吗？

尽管我特意将该表创建为堆表（无聚集索引），但我无法并行运行此语句。

update t
set new_col_1 = col_1
   ,new_col_2 = col_2
   ...
   , new_col_N = col_N
;

有 3 个文本列可容纳 400GB 数据。AWS RDS 的 IO 性能有限（10000 IOPS）。我们只有 4 小时的停机时间。

在此特定迁移中，不能选择在线重建，因为必须先将数据迁移（到 nvarchar），然后才能启动应用程序。在启动期间，它会检查实际数据类型是否与定义的数据类型（在应用程序元数据存储库中）相对应。

我知道碎片化，但我们别无选择。不过，如果有一些在线重建命令，它可能会很有用，因为我们稍后将能够进行迁移和碎片整理。实际上，作为准备步骤之一，我们正在删除聚集索引。稍后将再次创建该索引，我相信这将解决碎片问题，因为我们将从堆转移到 b*tree 结构。

令人非常沮丧的是我们无法使用任何其他“并行”技术。我正在考虑尝试手动并行更新，通过针对目标表的不重叠范围运行一些并行更新语句。尽管如此，锁升级可能是下一个问题，因为我将在每个更新中更新数百万条记录，并且很可能 SQL Server 将尝试升级到表锁，这将锁定其他更新，并且死机锁定将是最终结果..

我想计算两列，但需要在一行中获取第一列的结果。

SELECT country, COUNT(*)
FROM table1
GROUP BY country, type

这个查询给了我

country    type     COUNT(*)
Canada     first    22
Canada     second   42
Canada     third    15
Australia  second   23
Australia  third    18

但我需要得到

country    type_first   type_second   type_third
Canada     22           42            15
Australia  23           18            0

因为我想用这些值更新另一个表，并且使用这个行结构，我可以根据上述查询逐行更新国家/地区表。

UPDATE country SET first=x, second=x, third=x

注意：type列ENUM具有预定义的值。

在这个脚本上花时间

UPDATE 
    uk_data AS ud
  INNER JOIN 
    uk_pc AS up 
        ON ud.cat10 = up.WardCode
SET 
    ud.cat8 = up.Latitude,
    ud.cat9 = up.Longitude;

uk_pc表有 1,755,213 个条目和uk_data24,510 个条目。

在我没有时间的情况下，还有其他方法可以做到这一点吗？

我想更新uk_data cat8和cat9与uk_pc Latitude和Longitude。

Table1:  uk_pc
    Latitude
    Longitude
    WardCode

Table2:  uk_data
    cat8
    cat9
    cat10

在两个表中WardCode并且cat10具有相同的值。

表定义

表1 uk_data

CREATE TABLE IF NOT EXISTS `uk_data` (
  `slno` int(100) NOT NULL AUTO_INCREMENT,
  `comp_name` varchar(150) DEFAULT NULL,
  `comp_no` varchar(50) DEFAULT NULL,
  `comp_street` varchar(100) …

在 SQL Server 2012 上，我有一个用于将现有数据与新数据合并的中间/暂存表，我想在其中为新创建的行插入数字 ID：

ID   NaturalID               Comment

1    franknfurther03071972   blahblah
2    chrisrock12081980       nonsense
null clairecampbell24121990  merry christmas
3    walterhermes22032001    young guy
4    tanjaolsen16051996      nice
null timharris20041999       came late

带有“空”ID 的行是新的，编号的 ID 是那些已经存在于主目标表中的行。NaturalID 可以唯一标识一个条目（实际上是多列）。我想在当前最大 ID 之后将“空”ID 设置为增量值，此处为：5 和 6，在找到更多空 ID 时增加。

目前，我使用游标遍历 ID 为 null 的行并使用值更新每个 ID，但由于它确实是一个非常大的表，因此需要几天时间。

我尝试使用 row_number() 进行更新，但它给了我一个错误“窗口函数只能出现在 SELECT 或 ORDER BY 子句中。”：

update StagingTable set ID=ROW_NUMBER() over (order by NaturalId)
from StagingTable where id is null  -- fails

我该怎么做？