在PostgreSQL中，我可以这样做：
ALTER SEQUENCE serial RESTART WITH 0;
是否有甲骨文等价物？
Mauli
问问题
644000 次
18 回答
162
这是一个从 Oracle 大师Tom Kyte将任何序列重置为 0 的好程序。在下面的链接中也对利弊进行了很好的讨论。
tkyte@TKYTE901.US.ORACLE.COM>
create or replace
procedure reset_seq( p_seq_name in varchar2 )
is
l_val number;
begin
execute immediate
'select ' || p_seq_name || '.nextval from dual' INTO l_val;
execute immediate
'alter sequence ' || p_seq_name || ' increment by -' || l_val ||
' minvalue 0';
execute immediate
'select ' || p_seq_name || '.nextval from dual' INTO l_val;
execute immediate
'alter sequence ' || p_seq_name || ' increment by 1 minvalue 0';
end;
/
从此页面：动态 SQL 重置序列值
另一个很好的讨论也在这里：如何重置序列？
于 2008-09-18T15:34:52.270 回答
116
真正的重启是不可能的AFAIK。（如果我错了，请纠正我！）。
但是，如果要将其设置为 0，则可以删除并重新创建它。
如果要将其设置为特定值，可以将 INCREMENT 设置为负值并获取下一个值。
也就是说，如果您的序列为 500，则可以通过将其设置为 100
ALTER SEQUENCE serial INCREMENT BY -400;
SELECT serial.NEXTVAL FROM dual;
ALTER SEQUENCE serial INCREMENT BY 1;
于 2008-09-09T09:46:29.030 回答
66
alter sequence serial restart start with 1;
此功能在 18c 中正式添加，但自 12.1 起非官方可用。
在 12.1 中使用这个未记录的特性可以说是安全的。尽管官方文档中没有包含该语法，但它是由 Oracle 包DBMS_METADATA_DIFF生成的。我在生产系统上使用过几次。但是，我创建了一个 Oracle 服务请求，他们证实这不是文档错误，该功能确实不受支持。
在 18c 中，该功能没有出现在 SQL Language Syntax 中，但包含在Database Administrator's Guide中。
于 2013-10-30T03:31:27.340 回答
51
这是我的方法：
- 删除序列
- 重新创建它
例子：
--Drop sequence
DROP SEQUENCE MY_SEQ;
-- Create sequence
create sequence MY_SEQ
minvalue 1
maxvalue 999999999999999999999
start with 1
increment by 1
cache 20;
于 2010-05-19T14:56:29.633 回答
34
我的方法是对Dougman 示例的小幅扩展。
扩展是...
传入种子值作为参数。为什么？我喜欢称将序列重置为某个表中使用的最大 ID的东西。我最终从另一个脚本调用这个过程，该脚本对一大堆序列执行多次调用，将 nextval 重置回某个足够高的级别，在我使用序列的值作为唯一标识符的情况下不会导致主键违规。
它还尊重以前的minvalue。如果所需的p_val或现有的最小值高于当前或计算的下一个值，它实际上可能会将下一个值推得更高。
最重要的是，可以调用它来重置为指定值，然后等到最后看到包装器“修复我的所有序列”过程。
create or replace
procedure Reset_Sequence( p_seq_name in varchar2, p_val in number default 0)
is
l_current number := 0;
l_difference number := 0;
l_minvalue user_sequences.min_value%type := 0;
begin
select min_value
into l_minvalue
from user_sequences
where sequence_name = p_seq_name;
execute immediate
'select ' || p_seq_name || '.nextval from dual' INTO l_current;
if p_Val < l_minvalue then
l_difference := l_minvalue - l_current;
else
l_difference := p_Val - l_current;
end if;
if l_difference = 0 then
return;
end if;
execute immediate
'alter sequence ' || p_seq_name || ' increment by ' || l_difference ||
' minvalue ' || l_minvalue;
execute immediate
'select ' || p_seq_name || '.nextval from dual' INTO l_difference;
execute immediate
'alter sequence ' || p_seq_name || ' increment by 1 minvalue ' || l_minvalue;
end Reset_Sequence;
该过程本身很有用，但现在让我们添加另一个调用它并使用序列命名约定以编程方式指定所有内容并查找现有表/字段中使用的最大值...
create or replace
procedure Reset_Sequence_to_Data(
p_TableName varchar2,
p_FieldName varchar2
)
is
l_MaxUsed NUMBER;
BEGIN
execute immediate
'select coalesce(max(' || p_FieldName || '),0) from '|| p_TableName into l_MaxUsed;
Reset_Sequence( p_TableName || '_' || p_Fieldname || '_SEQ', l_MaxUsed );
END Reset_Sequence_to_Data;
现在我们用煤气做饭！
上面的过程将检查表中字段的最大值，从表/字段对构建序列名称，并使用检测到的最大值调用“Reset_Sequence” 。
接下来是这个难题的最后一块，锦上添花……
create or replace
procedure Reset_All_Sequences
is
BEGIN
Reset_Sequence_to_Data( 'ACTIVITYLOG', 'LOGID' );
Reset_Sequence_to_Data( 'JOBSTATE', 'JOBID' );
Reset_Sequence_to_Data( 'BATCH', 'BATCHID' );
END Reset_All_Sequences;
在我的实际数据库中，大约有一百个其他序列通过这种机制被重置，因此在上面的那个过程中还有 97 次对Reset_Sequence_to_Data的调用。
爱它？讨厌它？冷漠？
于 2011-05-19T17:35:59.060 回答
10
以下脚本将序列设置为所需的值：
给定一个新创建的名为 PCS_PROJ_KEY_SEQ 的序列和表 PCS_PROJ：
BEGIN
DECLARE
PROJ_KEY_MAX NUMBER := 0;
PROJ_KEY_CURRVAL NUMBER := 0;
BEGIN
SELECT MAX (PROJ_KEY) INTO PROJ_KEY_MAX FROM PCS_PROJ;
EXECUTE IMMEDIATE 'ALTER SEQUENCE PCS_PROJ_KEY_SEQ INCREMENT BY ' || PROJ_KEY_MAX;
SELECT PCS_PROJ_KEY_SEQ.NEXTVAL INTO PROJ_KEY_CURRVAL FROM DUAL;
EXECUTE IMMEDIATE 'ALTER SEQUENCE PCS_PROJ_KEY_SEQ INCREMENT BY 1';
END;
END;
/
于 2010-11-04T18:53:27.913 回答
6
这个存储过程重新启动了我的序列：
Create or Replace Procedure Reset_Sequence
is
SeqNbr Number;
begin
/* Reset Sequence 'seqXRef_RowID' to 0 */
Execute Immediate 'Select seqXRef.nextval from dual ' Into SeqNbr;
Execute Immediate 'Alter sequence seqXRef increment by - ' || TO_CHAR(SeqNbr) ;
Execute Immediate 'Select seqXRef.nextval from dual ' Into SeqNbr;
Execute Immediate 'Alter sequence seqXRef increment by 1';
END;
/
于 2009-07-29T17:23:58.290 回答
5
在 Oracle 中还有另一种重置序列的方法：设置maxvalue和cycle属性。当nextval序列的 命中 时maxvalue，如果cycle设置了属性，那么它将再次从minvalue序列的 开始。
与设置负数相比，此方法的优点increment by是可以在重置过程运行时继续使用序列，从而减少您需要采取某种形式的中断来进行重置的机会。
for 的值maxvalue必须大于 current ，因此下面的过程包括一个可选参数，允许缓冲区以防在过程中选择 和设置属性nextval之间再次访问序列。nextvalcycle
create sequence s start with 1 increment by 1;
select s.nextval from dual
connect by level <= 20;
NEXTVAL
----------
1
...
20
create or replace procedure reset_sequence ( i_buffer in pls_integer default 0)
as
maxval pls_integer;
begin
maxval := s.nextval + greatest(i_buffer, 0); --ensure we don't go backwards!
execute immediate 'alter sequence s cycle minvalue 0 maxvalue ' || maxval;
maxval := s.nextval;
execute immediate 'alter sequence s nocycle maxvalue 99999999999999';
end;
/
show errors
exec reset_sequence;
select s.nextval from dual;
NEXTVAL
----------
1
目前的过程仍然允许另一个会话获取值 0，这对您来说可能是也可能不是问题。如果是，您可以随时：
- 设置
minvalue 1在第一个改变 - 排除第二次
nextval提取 - 移动语句以将
nocycle属性设置到另一个过程中，以便在以后运行（假设您要这样做）。
于 2013-02-10T17:09:03.527 回答
4
1）假设您创建一个如下所示的序列：
CREATE SEQUENCE TESTSEQ
INCREMENT BY 1
MINVALUE 1
MAXVALUE 500
NOCACHE
NOCYCLE
NOORDER
2) 现在你从 SEQUENCE 中获取值。假设我已经取了四次，如下所示。
SELECT TESTSEQ.NEXTVAL FROM dual
SELECT TESTSEQ.NEXTVAL FROM dual
SELECT TESTSEQ.NEXTVAL FROM dual
SELECT TESTSEQ.NEXTVAL FROM dual
3) 执行上述四个命令后，SEQUENCE 的值为 4。现在假设我再次将 SEQUENCE 的值重置为 1。遵循以下步骤。按照相同的顺序执行所有步骤，如下所示：
ALTER SEQUENCE TESTSEQ INCREMENT BY -3;SELECT TESTSEQ.NEXTVAL FROM dualALTER SEQUENCE TESTSEQ INCREMENT BY 1;SELECT TESTSEQ.NEXTVAL FROM dual
于 2009-12-11T04:06:00.290 回答
3
Jezus，所有这些编程都只是为了重新启动索引......也许我是个白痴，但是对于 pre-oracle 12（它具有重新启动功能），一个简单的问题是什么：
drop sequence blah;
create sequence blah
?
于 2017-04-25T15:08:49.363 回答
2
改变序列的 INCREMENT 值，增加它，然后再改变它是非常轻松的，而且你有额外的好处，你不必重新建立所有的授权，就像你放弃/重新创建序列一样。
于 2008-09-15T15:17:57.640 回答
2
您可以使用 CYCLE 选项，如下所示：
CREATE SEQUENCE test_seq
MINVALUE 0
MAXVALUE 100
START WITH 0
INCREMENT BY 1
CYCLE;
在这种情况下，当序列达到 MAXVALUE (100) 时，它将循环到 MINVALUE (0)。
在递减序列的情况下，序列将循环到 MAXVALUE。
于 2014-03-25T15:51:05.743 回答
2
我创建了一个块来重置我的所有序列：
DECLARE
I_val number;
BEGIN
FOR US IN
(SELECT US.SEQUENCE_NAME FROM USER_SEQUENCES US)
LOOP
execute immediate 'select ' || US.SEQUENCE_NAME || '.nextval from dual' INTO l_val;
execute immediate 'alter sequence ' || US.SEQUENCE_NAME || ' increment by -' || l_val || ' minvalue 0';
execute immediate 'select ' || US.SEQUENCE_NAME || '.nextval from dual' INTO l_val;
execute immediate 'alter sequence ' || US.SEQUENCE_NAME || ' increment by 1 minvalue 0';
END LOOP;
END;
于 2015-06-04T19:08:46.083 回答
2
这是一个更强大的过程，用于更改序列返回的下一个值，以及更多。
- 首先，它可以防止 SQL 注入攻击，因为传入的字符串都不用于直接创建任何动态 SQL 语句，
- 其次，它防止下一个序列值设置在最小或最大序列值的范围之外。将
next_value是 !=min_value和介于min_value和之间max_value。 - 第三，它在清理时会考虑当前（或建议的）
increment_by设置以及所有其他序列设置。 - 第四，除第一个之外的所有参数都是可选的，除非指定，否则将当前序列设置作为默认值。如果未指定可选参数，则不采取任何操作。
- 最后，如果您尝试更改不存在（或不属于当前用户）的序列，它将引发
ORA-01403: no data found错误。
这是代码：
CREATE OR REPLACE PROCEDURE alter_sequence(
seq_name user_sequences.sequence_name%TYPE
, next_value user_sequences.last_number%TYPE := null
, increment_by user_sequences.increment_by%TYPE := null
, min_value user_sequences.min_value%TYPE := null
, max_value user_sequences.max_value%TYPE := null
, cycle_flag user_sequences.cycle_flag%TYPE := null
, cache_size user_sequences.cache_size%TYPE := null
, order_flag user_sequences.order_flag%TYPE := null)
AUTHID CURRENT_USER
AS
l_seq user_sequences%rowtype;
l_old_cache user_sequences.cache_size%TYPE;
l_next user_sequences.min_value%TYPE;
BEGIN
-- Get current sequence settings as defaults
SELECT * INTO l_seq FROM user_sequences WHERE sequence_name = seq_name;
-- Update target settings
l_old_cache := l_seq.cache_size;
l_seq.increment_by := nvl(increment_by, l_seq.increment_by);
l_seq.min_value := nvl(min_value, l_seq.min_value);
l_seq.max_value := nvl(max_value, l_seq.max_value);
l_seq.cycle_flag := nvl(cycle_flag, l_seq.cycle_flag);
l_seq.cache_size := nvl(cache_size, l_seq.cache_size);
l_seq.order_flag := nvl(order_flag, l_seq.order_flag);
IF next_value is NOT NULL THEN
-- Determine next value without exceeding limits
l_next := LEAST(GREATEST(next_value, l_seq.min_value+1),l_seq.max_value);
-- Grab the actual latest seq number
EXECUTE IMMEDIATE
'ALTER SEQUENCE '||l_seq.sequence_name
|| ' INCREMENT BY 1'
|| ' MINVALUE '||least(l_seq.min_value,l_seq.last_number-l_old_cache)
|| ' MAXVALUE '||greatest(l_seq.max_value,l_seq.last_number)
|| ' NOCACHE'
|| ' ORDER';
EXECUTE IMMEDIATE
'SELECT '||l_seq.sequence_name||'.NEXTVAL FROM DUAL'
INTO l_seq.last_number;
l_next := l_next-l_seq.last_number-1;
-- Reset the sequence number
IF l_next <> 0 THEN
EXECUTE IMMEDIATE
'ALTER SEQUENCE '||l_seq.sequence_name
|| ' INCREMENT BY '||l_next
|| ' MINVALUE '||least(l_seq.min_value,l_seq.last_number)
|| ' MAXVALUE '||greatest(l_seq.max_value,l_seq.last_number)
|| ' NOCACHE'
|| ' ORDER';
EXECUTE IMMEDIATE
'SELECT '||l_seq.sequence_name||'.NEXTVAL FROM DUAL'
INTO l_next;
END IF;
END IF;
-- Prepare Sequence for next use.
IF COALESCE( cycle_flag
, next_value
, increment_by
, min_value
, max_value
, cache_size
, order_flag) IS NOT NULL
THEN
EXECUTE IMMEDIATE
'ALTER SEQUENCE '||l_seq.sequence_name
|| ' INCREMENT BY '||l_seq.increment_by
|| ' MINVALUE '||l_seq.min_value
|| ' MAXVALUE '||l_seq.max_value
|| CASE l_seq.cycle_flag
WHEN 'Y' THEN ' CYCLE' ELSE ' NOCYCLE' END
|| CASE l_seq.cache_size
WHEN 0 THEN ' NOCACHE'
ELSE ' CACHE '||l_seq.cache_size END
|| CASE l_seq.order_flag
WHEN 'Y' THEN ' ORDER' ELSE ' NOORDER' END;
END IF;
END;
于 2015-08-14T19:32:49.663 回答
2
在我的项目中，一旦有人在不使用序列的情况下手动输入记录，因此我必须手动重置序列值，为此我在下面的 sql 代码片段中编写：
declare
max_db_value number(10,0);
cur_seq_value number(10,0);
counter number(10,0);
difference number(10,0);
dummy_number number(10);
begin
-- enter table name here
select max(id) into max_db_value from persons;
-- enter sequence name here
select last_number into cur_seq_value from user_sequences where sequence_name = 'SEQ_PERSONS';
difference := max_db_value - cur_seq_value;
for counter in 1..difference
loop
-- change sequence name here as well
select SEQ_PERSONS.nextval into dummy_number from dual;
end loop;
end;
请注意，如果序列滞后，上述代码将起作用。
于 2015-09-29T05:25:27.473 回答
1
我做了一个替代方案，用户不需要知道值，系统获取并使用变量来更新。
--Atualizando sequence da tabela SIGA_TRANSACAO, pois está desatualizada
DECLARE
actual_sequence_number INTEGER;
max_number_from_table INTEGER;
difference INTEGER;
BEGIN
SELECT [nome_da_sequence].nextval INTO actual_sequence_number FROM DUAL;
SELECT MAX([nome_da_coluna]) INTO max_number_from_table FROM [nome_da_tabela];
SELECT (max_number_from_table-actual_sequence_number) INTO difference FROM DUAL;
IF difference > 0 then
EXECUTE IMMEDIATE CONCAT('alter sequence [nome_da_sequence] increment by ', difference);
--aqui ele puxa o próximo valor usando o incremento necessário
SELECT [nome_da_sequence].nextval INTO actual_sequence_number from dual;
--aqui volta o incremento para 1, para que futuras inserções funcionem normalmente
EXECUTE IMMEDIATE 'ALTER SEQUENCE [nome_da_sequence] INCREMENT by 1';
DBMS_OUTPUT.put_line ('A sequence [nome_da_sequence] foi atualizada.');
ELSE
DBMS_OUTPUT.put_line ('A sequence [nome_da_sequence] NÃO foi atualizada, já estava OK!');
END IF;
END;
于 2016-04-28T20:05:20.337 回答
1
以下是如何使所有自增序列匹配实际数据：
创建一个过程来强制执行下一个值，如该线程中所述：
CREATE OR REPLACE PROCEDURE Reset_Sequence( P_Seq_Name IN VARCHAR2, P_Val IN NUMBER DEFAULT 0) IS L_Current NUMBER := 0; L_Difference NUMBER := 0; L_Minvalue User_Sequences.Min_Value%Type := 0; BEGIN SELECT Min_Value INTO L_Minvalue FROM User_Sequences WHERE Sequence_Name = P_Seq_Name; EXECUTE Immediate 'select ' || P_Seq_Name || '.nextval from dual' INTO L_Current; IF P_Val < L_Minvalue THEN L_Difference := L_Minvalue - L_Current; ELSE L_Difference := P_Val - L_Current; END IF; IF L_Difference = 0 THEN RETURN; END IF; EXECUTE Immediate 'alter sequence ' || P_Seq_Name || ' increment by ' || L_Difference || ' minvalue ' || L_Minvalue; EXECUTE Immediate 'select ' || P_Seq_Name || '.nextval from dual' INTO L_Difference; EXECUTE Immediate 'alter sequence ' || P_Seq_Name || ' increment by 1 minvalue ' || L_Minvalue; END Reset_Sequence;创建另一个过程以协调所有序列与实际内容：
CREATE OR REPLACE PROCEDURE RESET_USER_SEQUENCES_TO_DATA IS STMT CLOB; BEGIN SELECT 'select ''BEGIN'' || chr(10) || x || chr(10) || ''END;'' FROM (select listagg(x, chr(10)) within group (order by null) x FROM (' || X || '))' INTO STMT FROM (SELECT LISTAGG(X, ' union ') WITHIN GROUP ( ORDER BY NULL) X FROM (SELECT CHR(10) || 'select ''Reset_Sequence(''''' || SEQ_NAME || ''''','' || coalesce(max(' || COL_NAME || '), 0) || '');'' x from ' || TABLE_NAME X FROM (SELECT TABLE_NAME, REGEXP_SUBSTR(WTEXT, 'NEW\.(\S*) IS NULL',1,1,'i',1) COL_NAME, REGEXP_SUBSTR(BTEXT, '(\.|\s)([a-z_]*)\.nextval',1,1,'i',2) SEQ_NAME FROM USER_TRIGGERS LEFT JOIN (SELECT NAME BNAME, TEXT BTEXT FROM USER_SOURCE WHERE TYPE = 'TRIGGER' AND UPPER(TEXT) LIKE '%NEXTVAL%' ) ON BNAME = TRIGGER_NAME LEFT JOIN (SELECT NAME WNAME, TEXT WTEXT FROM USER_SOURCE WHERE TYPE = 'TRIGGER' AND UPPER(TEXT) LIKE '%IS NULL%' ) ON WNAME = TRIGGER_NAME WHERE TRIGGER_TYPE = 'BEFORE EACH ROW' AND TRIGGERING_EVENT = 'INSERT' ) ) ) ; EXECUTE IMMEDIATE STMT INTO STMT; --dbms_output.put_line(stmt); EXECUTE IMMEDIATE STMT; END RESET_USER_SEQUENCES_TO_DATA;
笔记：
- 过程从触发器代码中提取名称并且不依赖于命名约定
- 要在执行前检查生成的代码，请在最后两行切换注释
于 2017-01-08T15:35:00.180 回答
-1
对我有用的存储过程
create or replace
procedure reset_sequence( p_seq_name in varchar2, tablename in varchar2 )
is
l_val number;
maxvalueid number;
begin
execute immediate 'select ' || p_seq_name || '.nextval from dual' INTO l_val;
execute immediate 'select max(id) from ' || tablename INTO maxvalueid;
execute immediate 'alter sequence ' || p_seq_name || ' increment by -' || l_val || ' minvalue 0';
execute immediate 'select ' || p_seq_name || '.nextval from dual' INTO l_val;
execute immediate 'alter sequence ' || p_seq_name || ' increment by '|| maxvalueid ||' minvalue 0';
execute immediate 'select ' || p_seq_name || '.nextval from dual' INTO l_val;
execute immediate 'alter sequence ' || p_seq_name || ' increment by 1 minvalue 0';
end;
如何使用存储过程：
execute reset_sequence('company_sequence','company');
于 2019-11-18T22:03:48.357 回答