Newsgroup: it.comp.java
Titolo: chiavi auto generate

Se io inserisco una nuova riga nella tabella e l'inseirmento mi fa partire 
un trigger che genera un identificatore (tramite il meccanismo dei 
generatori di firebird ad esempio) e poi io voglio tale identificatore come 
faccio?
insert
..
select get_id(g, 0)
usando potrebbe dare problemi se si interpone tra la insert e la select un' 
altra insert.
Da java come posso risolvere il problema?
Oppure il problema é inesistente?
get_id ritorna l'ultimo id locale al thread se uso una stessa connessione? 

 select get_id(g, 0)
Metti le due chiamate in una transaction
Alex.
-- 
___________________________________________________________
a p bertolini
(Tribů Digitale Blackmambo: 
www.blackmambo.it
)

 get_id ritorna l'ultimo id locale al thread se uso una stessa connessione? 
No, il thread non c'entra nulla. Se get_id è una lettura sulla tabella 
(come immagino sia), ti ritorna l'ultimo id visibile per quella 
connessione. Una particolarità dei db transazionali è che garantiscono 
l'isolamento della transazione, ovvero: se con una connessione hai fatto 
delle modifiche al database, quelle modifiche le vedi solo da quella 
connessione finchè non le confermi con la commit. Quindi la get_id ti 
ritorna il *tuo* ultimo id locale, che è diverso da quello che vedono 
gli altri finchè non committi la tua insert.

 operazioni.
visto che parliamo di java da Connection.READ_COMMITTED in su sono al 
sicuro? 

 sicuro? 
Sei al sicuro se chiami setAutoCommit(false) e se non ti genera 
eccezioni (leggi: se il database supporta le transazioni).

Se il driver JDBC lo supporta, puoi richiedere l'id generato direttamente
leggendo il risultato della insert:
st.execute(SQLStatement, Statement.RETURN_GENERATED_KEYS);
return st.getGeneratedKeys();
Io uso PostgreSQL e, ahimé, non va.
Alex


...

io uso mysql con Autocommit(false) su tabelle di tipo INNODB (livello
transazionale)
l'id lo piglio dopo le insert (prima del commit) con una "SELECT
LAST_INSERT_ID()" (dal resultser ne prelevi il valore come r.getInt(1)
)
è la viariabile mysql in cui ci trovi l'ultimo ID generato dalla tua
connessione (puoi fare delle prove anche a mano da più
terminali/connessioni)
perfetto quanto detto da Vincent
ciao

 ha scritto nel messaggio 
news:5dba224a.04102...@posting.google.com...

Ok grazie a entrambi!
Ma se io faccio per curiosità:
connection.setAutoCommit(false);
connection.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
(oppure ho un manager che mi da già le connessioni con quel livello di 
isoltamento),
non nascono problemi?

...

non capisco la domanda
comunque l'isolatin level (per farla breve) serve per gestire le
contese tra task, mentre l'argomento del post che hai aperto riguarda
le chiavi autogenerate
in tale ambito l'unico problema che puoi avere è se più thread stanno
usando lo stesso oggetto connessione per fare le insert (se chiedi a
mysql l'ultimo ID inserito questo prescinde dall'isolation, mentre se
fai una select per determinarlo allora si che devi vedere con quale
isolation lavori)
in tal caso quando il tuo thread richiede il valore dell'ultimo ID
generato, potrebbe tornargli quello inserito da un'altro thread.
infatti il valore di ID generato che ti torna mysql è quello
dell'ultima insert avvenuta con quella connessione;
per non avere tale problemi o istanzi una nuova connessione ogni volta
che accedi al database, oppure se con ogni nuovo thread usi un oggetto
connessione già istanziato, allora l'oggetto connessione deve usare la
Synchronized nei metodi
io uso il primo esempio; ovviamente se ho più processi che accedono al
db in sequenza usano la stessa connessione già istanziata ad inizio
processo, ma se ne avvio più di uno in parallelo allora apro una nuova
connessione (come se fosse un altro terminale a lavorare); in poche
parole istanzio una connessione ad ogni inizio processo a prescindere
da quante volte con tale processo accedo al db, e faccio la commit
sono a fine processo chiudendo poi la connessione (questo perchè le
applicazione che ho fatto hanno una interfaccia utente, se invece le
applicazioni sono esposte come servizio, e quindi possono ricevere
molte richieste di i/o, allora forse è meglio aprire una o più la
connessioni all'apertura del servizio e poi accodare le richieste con
Synchonized per evitare di aprire una nuova connessione ad ogni
richiesta anche se di fatto viene evasa molto velocemente)
ciao