Réinitialiser la graine d'identité après la suppression des enregistrements dans SQL Server

J'ai inséré des enregistrements dans une table de base de données SQL Server. La table avait une clé primaire définie et la valeur de départ de l'incrémentation automatique est définie sur «Oui». Cela est principalement dû au fait que dans SQL Azure, chaque table doit avoir une clé primaire et une identité définies.

Mais comme je dois supprimer certains enregistrements de la table, la graine d'identité de ces tables sera perturbée et la colonne d'index (qui est générée automatiquement avec un incrément de 1) sera perturbée.

Comment puis-je réinitialiser la colonne d'identité après avoir supprimé les enregistrements afin que la colonne ait une séquence dans l'ordre numérique croissant?

La colonne d'identité n'est utilisée comme clé étrangère nulle part dans la base de données.

La DBCC CHECKIDENTcommande de gestion est utilisée pour réinitialiser le compteur d'identité. La syntaxe de la commande est:

DBCC CHECKIDENT (table_name [, { NORESEED | { RESEED [, new_reseed_value ]}}])
[ WITH NO_INFOMSGS ]

Exemple:

DBCC CHECKIDENT ('[TestTable]', RESEED, 0);
GO

Il n'était pas pris en charge dans les versions précédentes d'Azure SQL Database, mais il est désormais pris en charge.

Veuillez noter que l' new_reseed_valueargument varie selon les versions de SQL Server selon la documentation :

Si des lignes sont présentes dans le tableau, la ligne suivante est insérée avec la valeur new_reseed_value . Dans la version SQL Server 2008 R2 et versions antérieures, la ligne suivante insérée utilise new_reseed_value + la valeur d'incrément actuelle.

Cependant, je trouve ces informations trompeuses (tout simplement fausses en fait) car le comportement observé indique qu'au moins SQL Server 2012 utilise toujours new_reseed_value + la logique de valeur d'incrément actuelle. Microsoft contredit même son propre Example Ccontenu sur la même page:

C. Forcer la valeur d'identité actuelle à une nouvelle valeur

L'exemple suivant force la valeur d'identité actuelle dans la colonne AddressTypeID de la table AddressType à une valeur de 10. Étant donné que la table contient des lignes existantes, la ligne suivante insérée utilisera 11 comme valeur, c'est-à-dire la nouvelle valeur d'incrément actuelle définie pour la valeur de la colonne plus 1.

USE AdventureWorks2012;  
GO  
DBCC CHECKIDENT ('Person.AddressType', RESEED, 10);  
GO

Pourtant, tout cela laisse une option pour un comportement différent sur les nouvelles versions de SQL Server. Je suppose que la seule façon d'être sûr, jusqu'à ce que Microsoft clarifie les choses dans sa propre documentation, est de faire des tests réels avant utilisation.

DBCC CHECKIDENT ('TestTable', RESEED, 0)
GO

Où 0 est la identityvaleur de départ

Il convient de noter que SI toutes les données sont supprimées de la table via la clause DELETE(c'est-à-dire aucune WHEREclause), tant que a) les autorisations le permettent, et b) il n'y a pas de FK référençant la table (qui semble être le cas ici), l'utilisation TRUNCATE TABLEserait préférable car elle est plus efficace DELETE et réinitialise la IDENTITYgraine en même temps. Les détails suivants sont extraits de la page MSDN de TRUNCATE TABLE :

Par rapport à l'instruction DELETE, TRUNCATE TABLE présente les avantages suivants:

• Moins d'espace de journal des transactions est utilisé.

  L'instruction DELETE supprime les lignes une par une et enregistre une entrée dans le journal des transactions pour chaque ligne supprimée. TRUNCATE TABLE supprime les données en désallouant les pages de données utilisées pour stocker les données de table et n'enregistre que les désallocations de page dans le journal des transactions.

• Moins de verrous sont généralement utilisés.

  Lorsque l'instruction DELETE est exécutée à l'aide d'un verrou de ligne, chaque ligne de la table est verrouillée pour suppression. TRUNCATE TABLE verrouille toujours la table (y compris un verrou de schéma (SCH-M)) et la page mais pas chaque ligne.

• Sans exception, aucune page n'est laissée dans le tableau.

  Après l'exécution d'une instruction DELETE, la table peut toujours contenir des pages vides. Par exemple, les pages vides d'un tas ne peuvent pas être désallouées sans au moins un verrou de table exclusif (LCK_M_X). Si l'opération de suppression n'utilise pas de verrou de table, la table (segment) contiendra de nombreuses pages vides. Pour les index, l'opération de suppression peut laisser des pages vides, bien que ces pages soient rapidement désallouées par un processus de nettoyage en arrière-plan.

Si la table contient une colonne d'identité, le compteur de cette colonne est réinitialisé à la valeur de départ définie pour la colonne. Si aucune graine n'a été définie, la valeur par défaut 1 est utilisée. Pour conserver le compteur d'identité, utilisez plutôt DELETE.

Donc, ce qui suit:

DELETE FROM [MyTable];
DBCC CHECKIDENT ('[MyTable]', RESEED, 0);

Devient juste:

TRUNCATE TABLE [MyTable];

Veuillez consulter la TRUNCATE TABLEdocumentation (liée ci-dessus) pour plus d'informations sur les restrictions, etc.

Bien que la plupart des réponses suggèrent RESEED à 0, mais plusieurs fois, nous devons simplement réamorcer le prochain ID disponible

declare @max int
select @max=max([Id])from [TestTable]
if @max IS NULL   //check when max is returned as null
  SET @max = 0
DBCC CHECKIDENT ('[TestTable]', RESEED,@max)

Cela vérifiera le tableau et réinitialisera l'ID suivant.

J'ai essayé de @anil shahsrépondre et cela a réinitialisé l'identité. Mais quand une nouvelle ligne a été insérée, elle a obtenu le identity = 2. Au lieu de cela, j'ai changé la syntaxe:

DELETE FROM [TestTable]

DBCC CHECKIDENT ('[TestTable]', RESEED, 0)
GO

Ensuite, la première ligne obtiendra l'identité = 1.

Bien que la plupart des réponses suggèrent RESEEDà 0, et alors que certains voient cela comme un défaut pour les TRUNCATEDtables, Microsoft a une solution qui exclut laID

DBCC CHECKIDENT ('[TestTable]', RESEED)

Cela vérifiera le tableau et reviendra au suivant ID. Ceci est disponible depuis MS SQL 2005 jusqu'à la version actuelle.

https://msdn.microsoft.com/en-us/library/ms176057.aspx

l'émission de la commande 2 peut faire l'affaire

DBCC CHECKIDENT ('[TestTable]', RESEED,0)
DBCC CHECKIDENT ('[TestTable]', RESEED)

la première réinitialise l'identité à zéro et la suivante la remet à la prochaine valeur disponible - jacob

@Jacob

DBCC CHECKIDENT ('[TestTable]', RESEED,0)
DBCC CHECKIDENT ('[TestTable]', RESEED)

A fonctionné pour moi, je devais simplement effacer toutes les entrées du tableau, puis ajouter ce qui précède dans un point de déclenchement après la suppression. Maintenant, chaque fois que je supprime une entrée est prise de là.

Truncate La table est préférée car elle efface les enregistrements, réinitialise le compteur et récupère l'espace disque.

Deleteet CheckIdentdoit être utilisé uniquement lorsque les clés étrangères vous empêchent de tronquer.

Réinitialiser la colonne d'identité avec un nouvel identifiant ...

DECLARE @MAX INT
SELECT @MAX=ISNULL(MAX(Id),0) FROM [TestTable]

DBCC CHECKIDENT ('[TestTable]', RESEED,@MAX)

C'est une question courante et la réponse est toujours la même: ne le faites pas. Les valeurs d'identité doivent être traitées comme arbitraires et, en tant que telles, il n'y a pas d'ordre "correct".

Exécutez ce script pour réinitialiser la colonne d'identité. Vous devrez apporter deux modifications. Remplacez tableXYZ par la table que vous devez mettre à jour. En outre, le nom de la colonne d'identité doit être supprimé de la table temporaire. C'était instantané sur une table de 35 000 lignes et 3 colonnes. Évidemment, sauvegardez la table et essayez d'abord cela dans un environnement de test.

select * 
into #temp
From tableXYZ

set identity_insert tableXYZ ON

truncate table tableXYZ

alter table #temp drop column (nameOfIdentityColumn)

set identity_insert tableXYZ OFF

insert into tableXYZ
select * from #temp

DBCC CHECKIDENT (<TableName>, reseed, 0)

Cela mettra la valeur d'identité actuelle à 0.

Lors de l'insertion de la valeur suivante, la valeur d'identité est incrémentée à 1.

Utilisez cette procédure stockée:

IF (object_id('[dbo].[pResetIdentityField]') IS NULL)
  BEGIN
    EXEC('CREATE PROCEDURE [dbo].[pResetIdentityField] AS SELECT 1 FROM DUMMY');
  END
GO

SET  ANSI_NULLS ON
GO
SET  QUOTED_IDENTIFIER ON
GO

ALTER PROCEDURE [dbo].[pResetIdentityField]
  @pSchemaName NVARCHAR(1000)
, @pTableName NVARCHAR(1000) AS
DECLARE @max   INT;
DECLARE @fullTableName   NVARCHAR(2000) = @pSchemaName + '.' + @pTableName;

DECLARE @identityColumn   NVARCHAR(1000);

SELECT @identityColumn = c.[name]
FROM sys.tables t
     INNER JOIN sys.schemas s ON t.[schema_id] = s.[schema_id]
     INNER JOIN sys.columns c ON c.[object_id] = t.[object_id]
WHERE     c.is_identity = 1
      AND t.name = @pTableName
      AND s.[name] = @pSchemaName

IF @identityColumn IS NULL
  BEGIN
    RAISERROR(
      'One of the following is true: 1. the table you specified doesn''t have an identity field, 2. you specified an invalid schema, 3. you specified an invalid table'
    , 16
    , 1);
    RETURN;
  END;

DECLARE @sqlString   NVARCHAR(MAX) = N'SELECT @maxOut = max(' + @identityColumn + ') FROM ' + @fullTableName;

EXECUTE sp_executesql @stmt = @sqlString, @params = N'@maxOut int OUTPUT', @maxOut = @max OUTPUT

IF @max IS NULL
  SET @max = 0

print(@max)

DBCC CHECKIDENT (@fullTableName, RESEED, @max)
go

--exec pResetIdentityField 'dbo', 'Table'

Je reviens simplement sur ma réponse. Je suis tombé sur un comportement étrange dans SQL Server 2008 R2 que vous devez connaître.

drop table test01

create table test01 (Id int identity(1,1), descr nvarchar(10))

execute pResetIdentityField 'dbo', 'test01'

insert into test01 (descr) values('Item 1')

select * from test01

delete from test01

execute pResetIdentityField 'dbo', 'test01'

insert into test01 (descr) values('Item 1')

select * from test01

La première sélection produit 0, Item 1.

Le second produit 1, Item 1. Si vous exécutez la réinitialisation juste après la création de la table, la valeur suivante est 0. Honnêtement, je ne suis pas surpris que Microsoft ne puisse pas corriger ce problème. Je l'ai découvert parce que j'ai un fichier script qui remplit les tables de référence que j'exécute parfois après avoir recréé les tables et parfois lorsque les tables sont déjà créées.

J'utilise le script suivant pour ce faire. Il n'y a qu'un seul scénario dans lequel cela produira une "erreur", c'est-à-dire si vous avez supprimé toutes les lignes de la table et qu'il IDENT_CURRENTest actuellement défini sur 1, c'est-à-dire qu'il n'y avait qu'une seule ligne dans la table pour commencer.

DECLARE @maxID int = (SELECT MAX(ID) FROM dbo.Tbl)
;

IF @maxID IS NULL
    IF (SELECT IDENT_CURRENT('dbo.Tbl')) > 1
        DBCC CHECKIDENT ('dbo.Tbl', RESEED, 0)
    ELSE
        DBCC CHECKIDENT ('dbo.Tbl', RESEED, 1)
    ;
ELSE
    DBCC CHECKIDENT ('dbo.Tbl', RESEED, @maxID)
;

Pour une suppression complète des lignes et réinitialiser le nombre IDENTITY, j'utilise ceci (SQL Server 2008 R2)

USE mydb

-- ##################################################################################################################
-- DANGEROUS!!!! USE WITH CARE
-- ##################################################################################################################

DECLARE
  db_cursor CURSOR FOR
    SELECT TABLE_NAME
      FROM INFORMATION_SCHEMA.TABLES
     WHERE TABLE_TYPE = 'BASE TABLE'
       AND TABLE_CATALOG = 'mydb'

DECLARE @tblname VARCHAR(50)
SET @tblname = ''

OPEN db_cursor
FETCH NEXT FROM db_cursor INTO @tblname

WHILE @@FETCH_STATUS = 0
BEGIN
  IF CHARINDEX('mycommonwordforalltablesIwanttodothisto', @tblname) > 0
    BEGIN
      EXEC('DELETE FROM ' + @tblname)
      DBCC CHECKIDENT (@tblname, RESEED, 0)
    END

  FETCH NEXT FROM db_cursor INTO @tblname
END

CLOSE db_cursor
DEALLOCATE db_cursor
GO

Réinstaller à 0 n'est pas très pratique, sauf si vous nettoyez la table dans son ensemble.

sinon, la réponse donnée par Anthony Raymond est parfaite. Obtenez d'abord le maximum de la colonne d'identité, puis ajoutez-le à max.

J'ai essayé de faire cela pour un grand nombre de tables pendant le développement, et cela fonctionne comme un charme.

DBCC CHECKIDENT('www.newsType', RESEED, 1);
DBCC CHECKIDENT('www.newsType', RESEED);

Ainsi, vous le forcez d'abord à être défini sur 1, puis vous le définissez sur l'index le plus élevé des lignes présentes dans le tableau. Reste rapide et facile de l'idex.

Il est toujours préférable d'utiliser TRUNCATE lorsque cela est possible au lieu de supprimer tous les enregistrements car il n'utilise pas également l'espace de journal.

Dans le cas où nous avons besoin de supprimer et de réinitialiser la graine, rappelez-vous toujours que si la table n'a jamais été remplie et que vous l'avez utilisée, DBCC CHECKIDENT('tablenem',RESEED,0) le premier enregistrement obtiendra une identité = 0 comme indiqué dans la documentation msdn

Dans votre cas, reconstruisez uniquement l'index et ne vous inquiétez pas de perdre la série d'identités car il s'agit d'un scénario courant.

Première: Spécification d'identité Juste: "Non" >> Enregistrer le projet d'exécution de la base de données

Après cela: Spécification d'identité Juste: "OUI" >> Enregistrer le projet d'exécution de la base de données

Votre ID de base de données, PK À partir de 1 >>