Reset identity seed after deleting records in SQL Server

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

Where 0 is the identity start value.

Although most answers are suggesting RESEED to 0, many times we need to just reseed to next Id available

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) 

This will check the table and reset to the next ID.

It should be noted that IF all of the data is being removed from the table via the DELETE (i.e. no WHERE clause), then as long as a) permissions allow for it, and b) there are no FKs referencing the table (which appears to be the case here), using TRUNCATE TABLE would be preferred as it does a more efficient DELETE and resets the IDENTITY seed at the same time. The following details are taken from the MSDN page for TRUNCATE TABLE:

Compared to the DELETE statement, TRUNCATE TABLE has the following advantages:

• Less transaction log space is used.

  The DELETE statement removes rows one at a time and records an entry in the transaction log for each deleted row. TRUNCATE TABLE removes the data by deallocating the data pages used to store the table data and records only the page deallocations in the transaction log.

• Fewer locks are typically used.

  When the DELETE statement is executed using a row lock, each row in the table is locked for deletion. TRUNCATE TABLE always locks the table (including a schema (SCH-M) lock) and page but not each row.

• Without exception, zero pages are left in the table.

  After a DELETE statement is executed, the table can still contain empty pages. For example, empty pages in a heap cannot be deallocated without at least an exclusive (LCK_M_X) table lock. If the delete operation does not use a table lock, the table (heap) will contain many empty pages. For indexes, the delete operation can leave empty pages behind, although these pages will be deallocated quickly by a background cleanup process.

If the table contains an identity column, the counter for that column is reset to the seed value defined for the column. If no seed was defined, the default value 1 is used. To retain the identity counter, use DELETE instead.

So the following:

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

Becomes just:

TRUNCATE TABLE [MyTable]; 

Please see the TRUNCATE TABLE documentation (linked above) for additional information on restrictions, etc.

I tried @anil shahs answer and it reset the identity. But when a new row was inserted it got the identity = 2. So instead I changed the syntax to:

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

Then the first row will get the identity = 1.

Although most answers are suggesting RESEED to 0, and while some see this as a flaw for TRUNCATED tables, Microsoft has a solution that excludes the ID

DBCC CHECKIDENT ('[TestTable]', RESEED) 

This will check the table and reset to the next ID. This has been available since MS SQL 2005 to current.

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

Issuing two command can do the trick:

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

The first reset the identity to zero, and the next will set it to the next available value.

I have just used DBCC CHECKIDENT successfully.

Things to note:

• when referencing table name square brackets are not accepted

• DBCC CHECKIDENT('TableName',RESEED,n) will reset back to n+1

  • e.g. DBCC CHECKIDENT('tablename',RESEED,27) will start at 28

• If you are having issues with not setting the new starting ID - noting this you could fix this by:

  DECLARE @NewId as INT SET @NewId = (SELECT MAX('TableName')-1 AS ID FROM TableName) DBCC CHECKIDENT('TableName',RESEED,@MaxId) 

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

The above worked for me, I just had to clear all entries first from the table, then added the above in a trigger point after delete. Now whenever I delete an entry is taken from there.

you can CHECKIDENT To Reset Seed

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

Example

 DBCC CHECKIDENT ('TAble', reseed,0) 

-- Example Query

You can to insert the basic data with the following codes

first create one table after insert data to table

step to step i show data and Remove data for Show Details for understand Code

Result code : Create Table with rest seed Id I used dmv sys.identity_columns that table has identity

 --Create Table DROP TABLE IF EXISTS ExampleTable create table ExampleTable (Id Bigint identity(1,1), Name nvarchar(10)) --Insert to ExampleTable and Delete and Show identity insert into ExampleTable (Name) select 'Test1' as NAme union all select 'Test2' as NAme select * from ExampleTable | Id | Name | | -------- | -----| | 1 |Test1 | | 2 |Test2 | delete from ExampleTable insert into ExampleTable (Name) select 'Test3' as NAme select * from ExampleTable | Id | Name | | -------- | -----| | 3 |Test3 | delete from ExampleTable 

First check data if Table has not data use seed table

if Table has data use use Max id

after change seed with CHECKIDENT

--Find seedTable declare @reseed int=0 if(not exists( select top 1 * from ExampleTable)) begin SELECT @reseed=cast( seed_value as int) FROM sys.tables tables JOIN sys.identity_columns identity_columns ON tables.object_id=identity_columns.object_id where tables.name='ExampleTable' and OBJECT_SCHEMA_NAME(tables.object_id, db_id())='dbo' set @reseed=@reseed -1 end else begin --if Table Has Data and use Max id For seed set @reseed=(select top 1 id from ExampleTable order by id desc) end DBCC CHECKIDENT ('ExampleTable', reseed,@reseed) insert into ExampleTable (Name) select 'Test4' as NAme select * from ExampleTable | Id | Name | | -------- | -----| | 1 |Test4 | GO 

Truncate table is preferred because it clears the records, resets the counter and reclaims the disk space.

Delete and CheckIdent should be used only where foreign keys prevent you from truncating.

I use the following script to do this. There's only one scenario in which it will produce an "error", which is if you have deleted all rows from the table, and IDENT_CURRENT is currently set to 1, i.e. there was only one row in the table to begin with.

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

I've been trying to get this done for a large number of tables during development, and this works as a charm.

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

So, you first force it to be set to 1, then you set it to the highest index of the rows present in the table. Quick and easy rest of the idex.

Run this script to reset the identity column. You will need to make two changes. Replace tableXYZ with whatever table you need to update. Also, the name of the identity column needs dropped from the temp table. This was instantaneous on a table with 35,000 rows & 3 columns. Obviously, backup the table and first try this in a test environment.

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 

Reset identity column with new id...

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

This is a common question and the answer is always the same: don't do it. Identity values should be treated as arbitrary and, as such, there is no "correct" order.

DBCC CHECKIDENT (<TableName>, reseed, 0) 

This will set the current identity value to 0.

On inserting the next value, the identity value get incremented to 1.

Use this stored procedure:

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' 

Just revisiting my answer. I came across a weird behaviour in sql server 2008 r2 that you should be aware of.

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 

The first select produces 0, Item 1.

The second one produces 1, Item 1. If you execute the reset right after the table is created the next value is 0. Honestly, I am not surprised Microsoft cannot get this stuff right. I discovered it because I have a script file that populates reference tables that I sometimes run after I re-create tables and sometimes when the tables are already created.

Reseeding to 0 is not very practical unless you are cleaning up the table as a whole.

other wise the answer given by Anthony Raymond is perfect. Get the max of identity column first, then seed it with max.

It seems like the majority of replies here assumes that the table is empty and the Identity value needs to be reset. However, how I read the question is that @xorpower now has a table with records 1, 2, 3, 5, 6, 7, 12, 13, 14 etc...and wants a method to get that back to a contiguous list. (1, 2, 3, 4, 5, 6 , 7 , 8, 9 etc...)

cf But since I have to delete some records from the table, where some is the magic word here IMHO.

AFAIK there is no such a thing in MSSQL; worst case you can indeed dump the existing records table into a new table and go from there. The question to me to is also: why would you want to do that? And is an IDENTITY column then the best approach?

Anyway,the solutions provided here that do care about existing data are mostly about copying everything in a temp-table, TRUNCATEing the existing table; reseeding the table and then copying everything back again. I'm sure that works but if you have a lot of data then this is a pretty heavy operation. Personally I would rather go with creating an identical table, copying the data in that new table (maybe in batches?) and then finally SWITCHing the data to the original table and dropping the newly created table again. You're likely to need to do a CHECKIDENT after the SWITCH. This way you only need to move the data from one table to another once. To save space you could even DELETE the relevant records from the original table after a batch is copied.

PS: Yes, I know this is an old question, but given it's high points count it still shows up on top for similar questions and since nobody mentioned SWITCH yet it seemed worth adding.

Use this sp for all tables:

reseed 'youtable'

after delete a record (in a trigger p.e.) or when you needit.

CREATE procedure RESEED(@Tabla nvarchar(100)) as declare @CampoIdentidad nvarchar(100) SELECT @CampoIdentidad = Column_Name --,dbo.FN_EsIdentidad(Table_Name, Column_name) as EsIdentidad, --table_name, column_name FROM information_schema.columns where columnproperty ( object_id ( Table_Name ), Column_name , 'IsIdentity') = 1 and Table_Name=@Tabla declare @Sql nvarchar(max) declare @OutPutNum int set @Sql = 'Select MAX(' + @CampoIdentidad + ') From ' + @Tabla --select @CampoIdentidad set @sql = 'Select @ValorOut=COALESCE(max(' + @CampoIdentidad + '),0) From ' + @Tabla declare @ParamDefinition nvarchar(max) SET @ParamDefinition = '@ValorOut int OUTPUT' EXECUTE sp_executesql @SQL ,@ParamDefinition ,@ValorOut = @OutPutNum OUTPUT; --select @SQL DBCC CHECKIDENT (@Tabla, RESEED, @OutputNum) 

Using DBCC CHECKIDENT ('[tableName]', RESEED, [value]) to reset the IDENTITY column is what you want; however, there is something to keep in mind here:

• If the identity column is part of a unique index or PRIMARY KEY constraint, then you're going to immediately run into issues trying to add new records as the identity column does not guarantee uniqueness*

If the identity column has to be sequential with no gaps, then one thought that comes to mind is:

1. Copying the table data to a temporary table
2. Truncating the original table (this resets the identity specification to whatever was set for the column or the default value of 1)
3. Inserting the data back into the original table from the temporary table without the identity column
4. Dropping the temporary table.

*: IDENTITY (Property) (Transact-SQL)

For a complete DELETE rows and reset the IDENTITY count, I use this (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 

Hello this stored procedure DELETE ALL ROWS of a table and check whether has identity column in the table ,it will be reseed .

**** CAUTION : ALL ROWS WILL BE DELETED . *****

Create PROCEDURE ClearTableData @TableName varchar(100) AS EXEC ('ALTER TABLE '+@TableName+' NOCHECK CONSTRAINT ALL ') BEGIN TRY EXEC ('Truncate Table'+@TableName ) PRINT @TableName +' rows have trancated ' END TRY BEGIN CATCH EXEC ('Delete From '+@TableName ) PRINT @TableName +' rows have deleted ' END CATCH IF (OBJECTPROPERTY(OBJECT_ID(@TableName), 'TableHasIdentity')) = 1 DBCC CHECKIDENT (@TableName, RESEED, 0) EXEC ('ALTER TABLE '+@TableName+' CHECK CONSTRAINT ALL ') GO 

ALTER TABLE 'Name_table' AUTO_INCREMENT = 0;

Its always better to use TRUNCATE when possible instead of deleting all records as it doesn't use log space also.

In case we need delete and need to reset the seed, always remember that if table was never populated and you used DBCC CHECKIDENT('tablenem',RESEED,0) then first record will get identity = 0 as stated on msdn documentation

In your case only rebuild the index and don't worry about losing the series of identity as this is a common scenario.