Comment sequence.nextval peut-il être nul dans Oracle?

J'ai une séquence Oracle définie comme suit:

CREATE SEQUENCE  "DALLAS"."X_SEQ"  
    MINVALUE 0 
    MAXVALUE 999999999999999999999999999 
    INCREMENT BY 1 START WITH 0 NOCACHE  NOORDER  NOCYCLE ;

Il est utilisé dans une procédure stockée pour insérer un enregistrement:

PROCEDURE Insert_Record
                (p_name    IN  VARCHAR2,                
                 p_userid  IN  INTEGER,
                 cur_out   OUT TYPES_PKG.RefCursor)
    IS
        v_id NUMBER := 0;
    BEGIN
        -- Get id value from sequence
        SELECT x_seq.nextval
          INTO v_id
          FROM dual;

        -- Line below is X_PKG line 40
        INSERT INTO X
            (the_id,            
             name,                        
             update_userid)
          VALUES
            (v_id,
             p_name,                        
             p_userid);

        -- Return new id
        OPEN cur_out FOR
            SELECT v_id the_id
              FROM dual;
    END;

Parfois, cette procédure renvoie une erreur lorsqu'elle est exécutée à partir du code d'application.

ORA-01400: cannot insert NULL into ("DALLAS"."X"."THE_ID") 
ORA-06512: at "DALLAS.X_PKG", line 40 
ORA-06512: at line 1

Détails qui peuvent ou non être pertinents:

• Oracle Database 11g Enterprise Edition version 11.2.0.1.0 - Production 64 bits
• La procédure est exécutée via Microsoft.Practices.EnterpriseLibrary - Data.Oracle.OracleDatabase.ExecuteReader (commande DbCommand)
• L'application n'encapsule pas l'appel dans une transaction explicite.
• L'insert échoue par intermittence - moins de 1%

Dans quelles circonstances pourrait x_seq.nextvalêtre nul?

Je suis presque certain que cela finira par être un artefact de votre code ou du pilote .net que vous utilisez. J'ai créé une démo rapide pour vous en utilisant du SQL pur - PL / SQL et je n'ai jamais obtenu de valeur de séquence perdue. Soit dit en passant, le curseur de référence que vous utilisez est probablement inutile et a probablement un impact sur les performances et la lisibilité du code - ma démo comprend une procédure insert_record2 qui effectue régulièrement plus de 10% plus rapidement - en environ 26 secondes sur mon ordinateur portable contre 36 pour la version du curseur de référence. Je pense au moins aussi que c'est plus facile à comprendre. Vous pouvez évidemment exécuter une version modifiée sur votre base de données de test avec déclencheur d'audit.

/* 
demo for dbse 
assumes a user with create table, create sequence, create procedure pivs and quota. 

*/

drop table dbse13142 purge;

create table dbse13142(
    the_id number not null
,   name   varchar2(20)
,   userid number)
;

drop sequence x_seq;
CREATE SEQUENCE  X_SEQ NOCACHE  NOORDER  NOCYCLE ;

create or replace PROCEDURE Insert_Record
                (p_name    IN  VARCHAR2,                
                 p_userid  IN  INTEGER,
                 cur_out   OUT sys_refcursor)
    IS
        v_id NUMBER := 0;
    BEGIN
        -- Get id value from sequence
        SELECT x_seq.nextval
          INTO v_id
          FROM dual;

        -- Line below is X_PKG line 40
        INSERT INTO dbse13142
            (the_id,            
             name,                        
             userid)
          VALUES
            (v_id,
             p_name,                        
             p_userid);

        -- Return new id
        OPEN cur_out FOR
            SELECT v_id the_id
              FROM dual;
    END;
/


create or replace PROCEDURE Insert_Record2
                (p_name    IN  VARCHAR2,                
                 p_userid  IN  INTEGER,
                 p_theid   OUT dbse13142.the_id%type)
    IS
    BEGIN
        -- Get id value from sequence
        SELECT x_seq.nextval
          INTO p_theid
          FROM dual;

        -- Line below is X_PKG line 40
        INSERT INTO dbse13142
            (the_id,            
             name,                        
             userid)
          VALUES
            (p_theid,
             p_name,                        
             p_userid);
    END;
/

set timing on

declare
   c sys_refcursor;
begin   
for i in 1..100000 loop
   insert_record('User '||i,i,c);
   close c;
end loop;
commit;
end;
/

select count(*) from dbse13142;
truncate table dbse13142;

declare
  x number;
begin   
for i in 1..100000 loop
   insert_record2('User '||i,i,x);
end loop;
commit;
end;
/

select count(*) from dbse13142;
truncate table dbse13142;

Essayez de faire un cas de test. Créez une table fictive et insérez 100 000 enregistrements à l'aide de votre séquence dans la base de données. Je parie que vous n'aurez aucun problème. Essayez ensuite d'insérer la même chose à partir de votre application.

Cela peut-il être dû à d'autres problèmes tels qu'une non-concordance de client Oracle?

Une autre solution qui résoudrait le problème mais pas le problème consiste à ajouter un déclencheur sur la table.
Avant d'insérer sur la table sur Dallas.X SI: the_id est null THEN SELECT x_seq.nextval INTO: the_id FROM dual; FIN SI;

Je n'ai pas encore de privilèges pour faire des commentaires, alors écrivez ceci comme une réponse: puisque vous utilisez la version Oracle> = 11.1, qui autorise les séquences dans les expressions PL / SQL au lieu de SQL, essayez ceci:

   v_id := x_seq.nextval;

Au lieu de cela:

 -- Get id value from sequence
    SELECT x_seq.nextval
      INTO v_id
      FROM dual;

Ou, bien que j'aie entendu des doutes / pièges lors de l'utilisation de ".currval", peut-être omettre l'affectation séparée de v_id et utiliser uniquement ce code?:

 -- Line below is X_PKG line 40
        INSERT INTO X
            (the_id,            
             name,                        
             update_userid)
          VALUES
            (x_seq.nextval,
             p_name,                        
             p_userid);

        -- Return new id
        OPEN cur_out FOR
            SELECT x_seq.currval the_id
              FROM dual;

Désolé, je n'ai pas d'instance 11g à portée de main pour l'essayer.