如何在Oracle中重置序列？

Question

在PostgreSQL中，我可以这样做：

ALTER SEQUENCE serial RESTART WITH 0;

是否有Oracle等价物？

Answer 1

这是从Oracle guru 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;
/

从此页面：Dynamic SQL to reset sequence value
另一个很好的讨论也在这里：How to reset sequences?

Answer 2

无法进行真正的重启AFAIK。 （如果我错了，请纠正我。）。

但是，如果要将其设置为0，则只需删除并重新创建它即可。

如果要将其设置为特定值，可以将INCREMENT设置为负值并获取下一个值。

也就是说，如果序列为500，则可以通过

将其设置为100

ALTER SEQUENCE serial INCREMENT BY -400;
SELECT serial.NEXTVAL FROM dual;
ALTER SEQUENCE serial INCREMENT BY 1;

Answer 3

这是我的方法：

1. 删除序列
2. 重新创建

示例：

--Drop sequence

DROP SEQUENCE MY_SEQ;

-- Create sequence 

create sequence MY_SEQ
minvalue 1
maxvalue 999999999999999999999
start with 1
increment by 1
cache 20;

Answer 4

我的方法是对Dougman's example的延伸。

扩展程序是......

将种子值作为参数传递。为什么？我喜欢将重置序列的事情称为某些表中使用的最大ID 。我最终从另一个脚本调用此proc，该脚本对一大堆序列执行多次调用，将nextval重置为某个级别，该级别足够高，不会导致主键违规，我将序列的值用于唯一标识符。

它还尊重之前的 minvalue 。如果所需的 p_val 或现有的minvalue 高于当前或计算的下一个值，它实际上可以推动下一个值。

最重要的是，可以调用它来重置为指定值，并等到你看到包装器“修复所有序列”程序结束时。

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 的调用。

喜欢它吗？讨厌它？无动于衷？

Answer 5

alter sequence serial restart start with 0;

此功能是Oracle 12c中的新功能。它是{em>不包含在official documentation中。 我在Oracle软件包DBMS_METADATA_DIFF生成的脚本中找到了它。

警告：我在生产系统上多次使用过此功能，在我看来，在ad-hoc脚本中使用此命令是可以的。但您可能不希望将其作为应用程序的一部分包含在过程中。我创建了一个Oracle服务请求，询问此功能;它不仅仅是一个文档错误，它还是一个不受支持的功能。命令有可能在某一天消失，例如WM_CONCAT。 （虽然我认为不太可能 - Oracle语法很少消失，而且它是一个在内部至少在两个地方使用的简单功能。）

Answer 6

以下脚本将序列设置为所需的值：

给定一个名为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;
/

Answer 7

这stored procedure重启我的序列：

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;

/

Answer 8

在Oracle中还有另一种重置序列的方法：设置maxvalue和cycle属性。当序列的nextval点击maxvalue时，如果设置了cycle属性，那么它将从序列的minvalue重新开始。

与设置负increment by相比，此方法的优点是在重置过程运行时可以继续使用序列，从而减少了需要采取某种形式的中断来进行重置的可能性。

maxvalue的值必须大于当前nextval，因此下面的过程包括一个可选参数，允许缓冲区，以防在选择nextval之间再次访问序列在过程中并设置cycle属性。

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属性设置为另一个过程，以便稍后运行（假设您要执行此操作）。

Answer 9

Jezus，所有这些编程仅用于索引重启...... 也许我是个白痴，但是对于pre-oracle 12（它有一个重启功能），一个简单的问题是什么：

drop sequence blah;
create sequence blah 

Answer 10

更改序列的INCREMENT值，递增它，然后将其更改回来是非常轻松的，此外，您还可以不必重新建立所有授权，就像删除/重新创建序列一样。< / p>

Answer 11

在我的项目中，一旦有人手动输入记录而不使用序列，因此我必须手动重置序列值，我在下面写了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;

请注意，如果序列滞后，上述代码将起作用。

Answer 12

这是一个更强大的程序，用于更改序列返回的下一个值，还有更多。

• 首先它可以防止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;

Answer 13

我创建了一个块来重置所有序列：

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;

Answer 14

1）假设您创建了如下所示的SEQUENCE：

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。请按照以下步骤操作。按照如下所示的顺序执行所有步骤：

1. ALTER SEQUENCE TESTSEQ INCREMENT BY -3;
2. SELECT TESTSEQ.NEXTVAL FROM dual
3. ALTER SEQUENCE TESTSEQ INCREMENT BY 1;
4. SELECT TESTSEQ.NEXTVAL FROM dual

Answer 15

您可以使用CYCLE选项，如下所示：

CREATE SEQUENCE test_seq
MINVALUE 0
MAXVALUE 100
START WITH 0
INCREMENT BY 1
CYCLE;

在这种情况下，当序列达到MAXVALUE（100）时，它将循环到MINVALUE（0）。

在递减序列的情况下，序列将循环到MAXVALUE。

Answer 16

以下是如何使所有自动增量序列与实际数据匹配：

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;
   

2. 创建另一个程序以将所有序列与实际内容进行协调：

   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;
   

注意：

1. 过程从触发器代码中提取名称，不依赖于命名约定
2. 要在执行前检查生成的代码，请在最后两行切换注释

Answer 17

我做了一个替代方案，用户不需要知道值，系统获取并使用变量进行更新。

--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;

Answer 18

对我有用的存储过程

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');