Utilizzare SCOPE_IDENTITY() per restituire l'ultimo valore di identità inserito nello stesso ambito (SQL Server)

In SQL Server puoi utilizzare il SCOPE_IDENTITY() di T-SQL funzione per restituire l'ultimo valore di identità inserito in una colonna di identità nello stesso ambito.

Un ambito è un modulo (procedura memorizzata, trigger, funzione o batch). Se due istruzioni si trovano nella stessa stored procedure, funzione o batch, sono nello stesso ambito.

Tieni presente che restituisce l'ultimo valore di identità generato in qualsiasi tabella nella sessione corrente . Questo è in contrasto con IDENT_CURRENT() funzione, che restituisce l'ultimo valore di identità inserito per una determinata tabella , indipendentemente dalla sessione in cui si trova.

SCOPE_IDENTITY() è molto simile a @@IDENTITY in quanto entrambi restituiscono l'ultimo valore di identità inserito nella sessione corrente. La differenza è che SCOPE_IDENTITY() è limitato all'ambito corrente, mentre @@IDENTITY non è limitato a un ambito specifico.

Esempio 1 – Utilizzo di base

Ecco un esempio di codice di base di come funziona.

SELECT SCOPE_IDENTITY() AS [Last-Inserted Identity Value];

Risultato:

+--------------------------------+
| Last-Inserted Identity Value   |
|--------------------------------|
| NULL                           |
+--------------------------------+

Il motivo del risultato NULL è perché ho eseguito l'istruzione immediatamente dopo aver aperto una nuova connessione a SQL Server. Il SCOPE_IDENTITY() la funzione restituisce solo i risultati della sessione corrente.

Quindi, per ottenere un risultato non NULL, devo inserire un valore in una colonna di identità.

Esempio 2:inserire un valore per un risultato diverso da NULL

In questo esempio creo una tabella con una colonna identity. Quindi inserisco un valore predefinito in quella tabella prima di selezionare il contenuto della tabella e quindi eseguire SCOPE_IDENTITY() di nuovo.

CREATE TABLE scope_identity_test(id int IDENTITY(1,1));
INSERT scope_identity_test DEFAULT VALUES;
SELECT id FROM scope_identity_test;
SELECT SCOPE_IDENTITY() AS [Last-Inserted Identity Value];

Risultato:

+------+
| id   |
|------|
| 1    |
+------+
(1 row affected)
+--------------------------------+
| Last-Inserted Identity Value   |
|--------------------------------|
| 1                              |
+--------------------------------+
(1 row affected)

La tabella ha una riga e la sua colonna di identità ha un valore di 1. Questo è l'ultimo valore di identità inserito per la sessione corrente, quindi SCOPE_IDENTITY() restituisce anche 1.

Ora se aggiungo un'altra riga, il valore aumenta di conseguenza:

INSERT scope_identity_test DEFAULT VALUES;
SELECT id FROM scope_identity_test;
SELECT SCOPE_IDENTITY() AS [Last-Inserted Identity Value];

Risultato:

+------+
| id   |
|------|
| 1    |
| 2    |
+------+
(2 rows affected)
+--------------------------------+
| Last-Inserted Identity Value   |
|--------------------------------|
| 2                              |
+--------------------------------+
(1 row affected)

Risultati di una nuova sessione

Come accennato, SCOPE_IDENTITY() restituisce solo i risultati della stessa sessione. Questo vale anche per @@IDENTITY .

Quindi, se apro una nuova connessione a SQL Server ed eseguo il precedente SELECT affermazioni ancora, ottengo i seguenti risultati:

USE Test;
SELECT id FROM scope_identity_test;
SELECT SCOPE_IDENTITY() AS [Last-Inserted Identity Value];

Risultato:

+------+
| id   |
|------|
| 1    |
| 2    |
+------+
(2 rows affected)
+--------------------------------+
| Last-Inserted Identity Value   |
|--------------------------------|
| NULL                           |
+--------------------------------+
(1 row affected)

Ora inseriamo una nuova riga all'interno di questa nuova sessione:

INSERT scope_identity_test DEFAULT VALUES;
SELECT id FROM scope_identity_test;
SELECT SCOPE_IDENTITY() AS [Last-Inserted Identity Value];

Risultato:

+------+
| id   |
|------|
| 1    |
| 2    |
| 3    |
+------+
(1 row affected)
+--------------------------------+
| Last-Inserted Identity Value   |
|--------------------------------|
| 3                              |
+--------------------------------+
(3 rows affected)

Quindi ha raggiunto non appena ho inserito un nuovo valore di identità.

Tuttavia, torniamo alla sessione originale ed eseguiamo SELECT di nuovo le istruzioni (senza inserire una nuova riga):

SELECT id FROM scope_identity_test;
SELECT SCOPE_IDENTITY() AS [Last-Inserted Identity Value];

Risultato:

+------+
| id   |
|------|
| 1    |
| 2    |
| 3    |
+------+
(3 rows affected)
+--------------------------------+
| Last-Inserted Identity Value   |
|--------------------------------|
| 2                              |
+--------------------------------+
(1 row affected)

Quindi SCOPE_IDENTITY() della sessione originale i risultati non sono stati influenzati dalla seconda sessione.

Aggiunta di un secondo ambito

La cosa che differenzia SCOPE_IDENTITY() da @@IDENTITY , è quello SCOPE_IDENTITY() è limitato allo scopo attuale.

Ad esempio, se la tabella ha un trigger che inserisce un valore di identità in un'altra tabella, SCOPE_IDENTITY() riporterebbe solo il primo valore di identità. Ignorerebbe il valore di identità per la seconda tabella, perché è stata creata in un ambito diverso @@IDENTITY d'altra parte, riporterebbe il valore di identità per la seconda tabella (perché copre tutti gli ambiti).

Per un esempio di cosa intendo, vedi IDENT_CURRENT vs @@IDENTITY vs SCOPE_IDENTITY in SQL Server:qual è la differenza?

L'articolo illustra un esempio di trigger come quello di cui sto parlando qui.