Come può sequenza.nextval essere nullo in Oracle?

Ho una sequenza Oracle definita in questo modo:

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

Viene utilizzato in una procedura memorizzata per inserire un record:

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;

Occasionalmente, questa procedura restituisce un errore quando eseguita dal codice dell'applicazione.

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

Dettagli che potrebbero essere o non essere rilevanti:

• Oracle Database 11g Enterprise Edition versione 11.2.0.1.0 - Produzione a 64 bit
• La procedura viene eseguita tramite Microsoft.Practices.EnterpriseLibrary - Data.Oracle.OracleDatabase.ExecuteReader (comando DbCommand)
• L'applicazione non avvolge la chiamata in una transazione esplicita.
• L'inserimento non riesce a intermittenza - meno dell'1%

In quali circostanze potrebbe x_seq.nextvalessere nullo?

Sono abbastanza sicuro che questo finirà per essere un artefatto del tuo codice o del driver .net che stai utilizzando. Ho realizzato una rapida demo per te usando SQL - PL / SQL puro e non ho mai perso un valore di sequenza. Per inciso, il cursore ref che stai usando non è probabilmente necessario e probabilmente influisce sulle prestazioni e sulla leggibilità del codice: la mia demo include una procedura insert_record2 che esegue costantemente più del 10% più veloce, in circa 26 secondi sul mio laptop contro 36 per la versione del cursore ref. Almeno penso anche che sia più facile da capire. Ovviamente potresti eseguire una versione modificata sul tuo database di test completo di trigger di controllo.

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

Prova a fare un caso di prova. Crea una tabella fittizia e inserisci 100.000 record utilizzando la sequenza dal database. Scommetto che non avrai problemi. Quindi prova a inserire la stessa cosa dalla tua applicazione.

Ciò potrebbe essere causato da altri problemi come una mancata corrispondenza del client Oracle?

Un'altra soluzione che risolve il problema ma non il problema è aggiungere un trigger sulla tabella.
Prima di inserire sulla tabella su Dallas.X IF: the_id è null ALLORA SELEZIONA x_seq.nextval INTO: the_id FROM dual; FINISCI SE;

Non ho ancora i privilegi per fare commenti, quindi scrivilo come una risposta: Dato che stai usando la versione Oracle> = 11.1, che consente sequenze nelle espressioni PL / SQL anziché in SQL, prova questo:

   v_id := x_seq.nextval;

Invece di questo:

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

Oppure, anche se ho sentito dubbi / insidie ​​quando ho usato ".currval", forse ometti l'assegnazione separata di v_id e usi solo questo codice ?:

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

Mi dispiace non avere un'istanza 11g a portata di mano ora per provare questo.