Sql 针对无序主键列的海量主键版本

我有一个数据库和一些表，每个表都有

ID

主键列。所有

ID

都包含大量随机数，如

827140014

，

9827141241

等。从1（

1

，

2

，

3

等）开始，按时间顺序编辑和更改此值的最简单方法是什么？行的顺序无关紧要

我想为SQL Server、Oracle、PostgreSQL和SQLite做这件事（每种都有不同的解决方案）

另外，假设有一些表依赖于

ID

（外键）。

对于Oracle

a） 。如果有表引用要更新的表，那么首先要做的是禁用外键约束。您可以使用以下查询生成所有

ALTER

语句：

SELECT 'ALTER TABLE ' || owner || '.' || table_name ||
       ' DISABLE CONSTRAINT ' || constraint_name || ';'
  FROM all_constraints
WHERE constraint_type = 'R'
  AND r_constraint_name = 
                        (SELECT constraint_name
                          FROM all_constraints
                         WHERE constraint_type = 'P'
                           AND table_name = 'YOUR_TABLE_NAME'
                           AND owner = 'OWNER_OF_THAT_TABLE');

b） 。运行生成的ALTER语句

c） 。接下来，您必须生成新ID。您可以添加新列来保存这些值，也可以创建临时表。新列方法：

ALTER TABLE YOUR_TABLE_NAME ADD temp_new_id NUMBER;

d） 。填充列：

-- Create a sequence to generate new IDs
CREATE SEQUENCE YOUR_TABLE_NAME_seq START WITH 1 CACHE 20;
UPDATE YOUR_TABLE_NAME SET temp_new_id = YOUR_TABLE_NAME_seq.nextVal;
COMMIT;

e） 。以以下方式更新每个从属表中的ID：

UPDATE some_dep_table sdt SET sdt.master_table_id = 
  (SELECT ytn.temp_new_id FROM YOUR_TABLE_NAME ytn WHERE sdt.master_table_id = ytn.id);
COMMIT;

f） 。更新表格-将ID从临时列移动到ID为的实际列：

UPDATE YOUR_TABLE_NAME SET id = temp_new_id;
COMMIT;

g） 。从表中删除临时列：

ALTER TABLE YOUR_TABLE_NAME DROP COLUMN temp_new_id;

h） 。对依赖表启用约束（使用查询从a点生成约束），只需将禁用替换为启用即可。

对于Oracle

a） 。如果有表引用要更新的表，那么首先要做的是禁用外键约束。您可以使用以下查询生成所有

ALTER

语句：

SELECT 'ALTER TABLE ' || owner || '.' || table_name ||
       ' DISABLE CONSTRAINT ' || constraint_name || ';'
  FROM all_constraints
WHERE constraint_type = 'R'
  AND r_constraint_name = 
                        (SELECT constraint_name
                          FROM all_constraints
                         WHERE constraint_type = 'P'
                           AND table_name = 'YOUR_TABLE_NAME'
                           AND owner = 'OWNER_OF_THAT_TABLE');

b） 。运行生成的ALTER语句

c） 。接下来，您必须生成新ID。您可以添加新列来保存这些值，也可以创建临时表。新列方法：

ALTER TABLE YOUR_TABLE_NAME ADD temp_new_id NUMBER;

d） 。填充列：

-- Create a sequence to generate new IDs
CREATE SEQUENCE YOUR_TABLE_NAME_seq START WITH 1 CACHE 20;
UPDATE YOUR_TABLE_NAME SET temp_new_id = YOUR_TABLE_NAME_seq.nextVal;
COMMIT;

e） 。以以下方式更新每个从属表中的ID：

UPDATE some_dep_table sdt SET sdt.master_table_id = 
  (SELECT ytn.temp_new_id FROM YOUR_TABLE_NAME ytn WHERE sdt.master_table_id = ytn.id);
COMMIT;

f） 。更新表格-将ID从临时列移动到ID为的实际列：

UPDATE YOUR_TABLE_NAME SET id = temp_new_id;
COMMIT;

g） 。从表中删除临时列：

ALTER TABLE YOUR_TABLE_NAME DROP COLUMN temp_new_id;

h） 。对依赖表启用约束（使用查询从a点生成约束），只需将禁用替换为启用即可。

对于Oracle

a） 。如果有表引用要更新的表，那么首先要做的是禁用外键约束。您可以使用以下查询生成所有

ALTER

语句：

SELECT 'ALTER TABLE ' || owner || '.' || table_name ||
       ' DISABLE CONSTRAINT ' || constraint_name || ';'
  FROM all_constraints
WHERE constraint_type = 'R'
  AND r_constraint_name = 
                        (SELECT constraint_name
                          FROM all_constraints
                         WHERE constraint_type = 'P'
                           AND table_name = 'YOUR_TABLE_NAME'
                           AND owner = 'OWNER_OF_THAT_TABLE');

b） 。运行生成的ALTER语句

c） 。接下来，您必须生成新ID。您可以添加新列来保存这些值，也可以创建临时表。新列方法：

ALTER TABLE YOUR_TABLE_NAME ADD temp_new_id NUMBER;

d） 。填充列：

-- Create a sequence to generate new IDs
CREATE SEQUENCE YOUR_TABLE_NAME_seq START WITH 1 CACHE 20;
UPDATE YOUR_TABLE_NAME SET temp_new_id = YOUR_TABLE_NAME_seq.nextVal;
COMMIT;

e） 。以以下方式更新每个从属表中的ID：

UPDATE some_dep_table sdt SET sdt.master_table_id = 
  (SELECT ytn.temp_new_id FROM YOUR_TABLE_NAME ytn WHERE sdt.master_table_id = ytn.id);
COMMIT;

f） 。更新表格-将ID从临时列移动到ID为的实际列：

UPDATE YOUR_TABLE_NAME SET id = temp_new_id;
COMMIT;

g） 。从表中删除临时列：

ALTER TABLE YOUR_TABLE_NAME DROP COLUMN temp_new_id;

h） 。对依赖表启用约束（使用查询从a点生成约束），只需将禁用替换为启用即可。

对于Oracle

a） 。如果有表引用要更新的表，那么首先要做的是禁用外键约束。您可以使用以下查询生成所有

ALTER

语句：

SELECT 'ALTER TABLE ' || owner || '.' || table_name ||
       ' DISABLE CONSTRAINT ' || constraint_name || ';'
  FROM all_constraints
WHERE constraint_type = 'R'
  AND r_constraint_name = 
                        (SELECT constraint_name
                          FROM all_constraints
                         WHERE constraint_type = 'P'
                           AND table_name = 'YOUR_TABLE_NAME'
                           AND owner = 'OWNER_OF_THAT_TABLE');

b） 。运行生成的ALTER语句

c） 。接下来，您必须生成新ID。您可以添加新列来保存这些值，也可以创建临时表。新列方法：

ALTER TABLE YOUR_TABLE_NAME ADD temp_new_id NUMBER;

d） 。填充列：

-- Create a sequence to generate new IDs
CREATE SEQUENCE YOUR_TABLE_NAME_seq START WITH 1 CACHE 20;
UPDATE YOUR_TABLE_NAME SET temp_new_id = YOUR_TABLE_NAME_seq.nextVal;
COMMIT;

e） 。以以下方式更新每个从属表中的ID：

UPDATE some_dep_table sdt SET sdt.master_table_id = 
  (SELECT ytn.temp_new_id FROM YOUR_TABLE_NAME ytn WHERE sdt.master_table_id = ytn.id);
COMMIT;

f） 。更新表格-将ID从临时列移动到ID为的实际列：

UPDATE YOUR_TABLE_NAME SET id = temp_new_id;
COMMIT;

g） 。从表中删除临时列：

ALTER TABLE YOUR_TABLE_NAME DROP COLUMN temp_new_id;

---

h） 。在依赖表上启用约束（使用查询从点a生成约束），只需将禁用替换为启用即可。

Oracle解决方案：给定表，列id为主键的某个表：

CREATE TABLE my_order AS SELECT id, rownum rn FROM some_table;
ALTER TABLE my_order ADD CONSTRAINT pk_order PRIMARY KEY (id);

UPDATE
  (SELECT t.*, o.rn FROM some_table t JOIN my_order o on (t.id = o.id))
SET id = rn;

DROP TABLE my_order;

您应该能够在PostgreSQL中运行类似的操作，只需使用分析函数row_number而不是Oracle的rownum。我不确定其他引擎

---

对于引用表，只需确保外键约束在更新级联上。

Oracle解决方案：给定表，列id作为主键的某个表：

CREATE TABLE my_order AS SELECT id, rownum rn FROM some_table;
ALTER TABLE my_order ADD CONSTRAINT pk_order PRIMARY KEY (id);

UPDATE
  (SELECT t.*, o.rn FROM some_table t JOIN my_order o on (t.id = o.id))
SET id = rn;

DROP TABLE my_order;

您应该能够在PostgreSQL中运行类似的操作，只需使用分析函数row_number而不是Oracle的rownum。我不确定其他引擎

---

对于引用表，只需确保外键约束在更新级联上。

Oracle解决方案：给定表，列id作为主键的某个表：

CREATE TABLE my_order AS SELECT id, rownum rn FROM some_table;
ALTER TABLE my_order ADD CONSTRAINT pk_order PRIMARY KEY (id);

UPDATE
  (SELECT t.*, o.rn FROM some_table t JOIN my_order o on (t.id = o.id))
SET id = rn;

DROP TABLE my_order;

您应该能够在PostgreSQL中运行类似的操作，只需使用分析函数row_number而不是Oracle的rownum。我不确定其他引擎

---

对于引用表，只需确保外键约束在更新级联上。

Oracle解决方案：给定表，列id作为主键的某个表：

CREATE TABLE my_order AS SELECT id, rownum rn FROM some_table;
ALTER TABLE my_order ADD CONSTRAINT pk_order PRIMARY KEY (id);

UPDATE
  (SELECT t.*, o.rn FROM some_table t JOIN my_order o on (t.id = o.id))
SET id = rn;

DROP TABLE my_order;

您应该能够在PostgreSQL中运行类似的操作，只需使用分析函数row_number而不是Oracle的rownum。我不确定其他引擎

对于引用表，只需确保外键约束位于更新级联上。

对于PostgreSQL：

UPDATE table SET id = t.new_id

FROM (
    SELECT id as old_id, ROW_NUMBER() OVER (ORDER BY id) AS new_id
    FROM table
) t

WHERE id = t.old_id

这将用（1，2，…）替换ID并保存它们的顺序。

对于PostgreSQL：

UPDATE table SET id = t.new_id

FROM (
    SELECT id as old_id, ROW_NUMBER() OVER (ORDER BY id) AS new_id
    FROM table
) t

WHERE id = t.old_id

这将用（1，2，…）替换ID并保存它们的顺序。

对于PostgreSQL：

UPDATE table SET id = t.new_id

FROM (
    SELECT id as old_id, ROW_NUMBER() OVER (ORDER BY id) AS new_id
    FROM table
) t

WHERE id = t.old_id

这将用（1，2，…）替换ID并保存它们的顺序。

对于PostgreSQL：

UPDATE table SET id = t.new_id

FROM (
    SELECT id as old_id, ROW_NUMBER() OVER (ORDER BY id) AS new_id
    FROM table
) t

WHERE id = t.old_id

---

这将用（1，2，…）替换ID并保存它们的顺序。

是否有任何表引用

ID

列？否，但如果可能的话，我想知道postgresql的两种解决方案（我最初在postgres标记中看到了这一点），如果这些值是（tablename）上一次性排序

集群（tablename）的主键_pkey

应按该顺序对行进行排序。注意，它将重新创建表并对行进行排序，因此如果行数达到数百万，则可能需要一些时间。其他数据