I am using SqlServer 2005 and I have a table in which I have an auto incrementing column but for some reason the auto increment field does not start with 1 but with some random number like 21,91. Why does that happen?
You either need to set the Seed for the column.... or if you had entered rows previously, you need to execute a TRUNCATE TABLE command on the table...
TRUNCATE TABLE XYZ
mssql is not using max(id) + 1 as identity like other databases. It is storing the last used id and is incrementing it.
You can reseed the identity:
DBCC CHECKIDENT ('tablex', RESEED, 1)
or truncate the table, this is also deleting all the data:
TRUNCATE TABLE tablex
You can of course combine the identity reseed with the last value:
DBCC CHECKIDENT ('tablex', RESEED, (SELECT max(id) + 1 FROM tablex))
But be aware of producing errors on reseeding the id due to conflicts, the auto increment id is unique!
Related
I have a database whose last index was 419728 and I want to insert data starting from 421662 and ignore the value starting from 419279 to 421661
is it possible to jump in that values?
DBCC CHECKIDENT can reset the identity value of the table.
If you want next record to have identity as 421662, execute following:
DBCC CHECKIDENT (table_name, reseed, 421661)
HTH!
In SQL Server 2012, the following query is seeding the identity column myTable_id from 2 instead of 1. Why? myTable_id is also PK.
DELETE FROM myTable;
GO
SELECT * FROM myTable --0 rows are returned as expected
GO
DBCC CHECKIDENT(myTable, RESEED,1)
GO
INSERT INTO myTable(col1,col2,col3) SELECT FROM AnotherTable(col1,col2,col3)
GO
SELECT * FROM myTable --1005 rows are returned as expected, but identity value starts from 2
GO
Remark:
The data inserted is right, the only issue is that the newly inserted data starts from 2 instead of 1.
In the above sql code if I use DBCC CHECKIDENT(myTable, RESEED,0) the identity column correctly starts from 1.
Following is snapshot in SSMS for the myTable_id column:
From the docs:
The seed value is the value inserted into an identity column for the very first row loaded into the table. All subsequent rows contain the current identity value plus the increment value where current identity value is the last identity value generated for the table or view.
So if you seed from 10, the next value to be inserted will be 11.
There is nothing bad with the answer here but the confusion comes from Microsoft approach itself.
I think that:
DBCC CHECKIDENT(myTable, RESEED, 0)
Should have the same behavior everywhere:
on new created table,
after delete table records,
after truncating the table
Otherwise we need to check the table status before running this.
Works as expected see also
https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-checkident-transact-sql#examples
The value 1 means that the current identity will be at 1 and the next identity will start on 2
To get it starting on 1 you should do
DBCC CHECKIDENT(myTable, RESEED, 0)
This does the trick for me:
DBCC CHECKIDENT ([Table], RESEED, 0)
DBCC CHECKIDENT ([Table], RESEED)
I have one table called customer_master that includes a column called cust_id with autoincrement set to 1.
When we try to insert records its working fine and inserted records like cust_id 1, 2, 3 and 4 are inserted, but when an error is generated in the insert command we do a transaction rollback, this means that cust_id 5 is not inserted, but when we are insert another record, cust_id generates 6. It skips cust_id 5.
I want to set it up so that if any error is generated in the insert command the identity is not incremented.
We are using c# and sql server 2005.
The reason SQL Server does this is for efficiency. If you need a sequence number without gaps you shouldn't be using identity you would need to implement your own scheme where concurrent transactions are blocked waiting for the next value just in case the initial transaction rolls back.
The second query here could be used for that purpose. But do you really need this? If it is purely for aesthetic purposes my advice is not to worry about it!
You can use DBCC CHECKIDENT to reseed the identity column after an insert failure.
DBCC CHECKIDENT ( table_name, NORESEED ) returns the current identity value and the current maximum value of the identity column.
DBCC CHECKIDENT ( table_name, RESEED, new_reseed_value ) sets the current identity value to the new_reseed_value.
Is there any way of changing the identity seed for an identity column permanently? Using DBCC CHECKIDENT just seems to set the last_value. If the table is truncated all values are reset.
dbcc checkident ('__Test_SeedIdent', reseed, 1000)
select name, seed_value, increment_value, last_value
from sys.identity_columns
where [object_id] = OBJECT_ID('__Test_SeedIdent');
returns
name seed_value increment_value last_value
-------------------------------------------------
idIdent 1 1 1000
I was hoping that some syntax like
alter table dbo.__Test_SeedIdent alter column idIdent [int] identity(1000,1) NOT NULL
would exist.
Is it necessary to create a new column, move the values across, drop the original column and rename the new?
From Books Online:
"To change the original seed value and reseed any existing rows, you must drop the identity column and recreate it specifying the new seed value. When the table contains data, the identity numbers are added to the existing rows with the specified seed and increment values. The order in which the rows are updated is not guaranteed."
MSSQL does not allow you to add or alter an Identity on an existing column via TSQL very easily. You would have to drop the column and re-add it. Needless to say this can play hell with FK relations. You can do it directly in the enterprise manager. However that won't be fun if you have to do this to a LOT of columns.
Is it necessary to create a new
column, move the values across, drop
the original column and rename the
new?
Yup, and don't forget to fix/update all indexes, foreign key relationships, etc. that are tied to that column
You can use DBCC CHECKIDENT('tablename', RESEED, seedvalue)
example: DBCC CHECKIDENT('Customers',RESEED, 1350)
run DBCC CHECKIDENT('Customers') again to check if current seed value was set.
However as mentioned in previous answers this will not change existing values stored in the identity column. It will only change seed value so the next row that is inserted will start with that value. Identity increment remains same (not changed) and can not be changed with DBCC.
"Is it necessary to create a new column, move the values across, drop the original column and rename the new?"
Actually in Enterprise Manager, when you add an ID column to an existing table (or change an INT PK field to an INT PK ID), it does this behind the scene.
I've deleted some records from a table in a SQL Server database.
The IDs in the table look like this:
99
100
101
1200
1201...
I want to delete the later records (IDs >1200), then I want to reset the auto increment so the next autogenerated ID will be 102. So my records are sequential, Is there a way to do this in SQL Server?
Issue the following command to reseed mytable to start at 1:
DBCC CHECKIDENT (mytable, RESEED, 0)
Read about it in the Books on Line (BOL, SQL help). Also be careful that you don't have records higher than the seed you are setting.
DBCC CHECKIDENT('databasename.dbo.tablename', RESEED, number)
if number = 0 then in the next insert the auto increment field will contain value 1
if number = 101 then in the next insert the auto increment field will contain value 102
Some additional info... May be useful to you
Before giving auto increment number in above query, you have to make sure your existing table's auto increment column contain values less that number.
To get the maximum value of a column(column_name) from a table(table1), you can use following query
SELECT MAX(column_name) FROM table1
semi idiot-proof:
declare #max int;
select #max = max(key) from table;
dbcc checkident(table,reseed,#max)
http://sqlserverplanet.com/tsql/using-dbcc-checkident-to-reseed-a-table-after-delete
If you're using MySQL, try this:
ALTER TABLE tablename AUTO_INCREMENT = 1
I figured it out. It's:
DBCC CHECKIDENT ('tablename', RESEED, newseed)
Delete and Reseed all the tables in a database.
USE [DatabaseName]
EXEC sp_msforeachtable "ALTER TABLE ? NOCHECK CONSTRAINT all" -- Disable All the constraints
EXEC sp_MSForEachTable "DELETE FROM ?" -- Delete All the Table data
Exec sp_MSforeachtable 'DBCC CHECKIDENT(''?'', RESEED, 0)' -- Reseed All the table to 0
Exec sp_msforeachtable "ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all" -- Enable All the constraints back
-- You may ignore the errors that shows the table without Auto increment field.
Based on the accepted answer, for those who encountered a similar issue, with full schema qualification:
([MyDataBase].[MySchemaName].[MyTable])... results in an error, you need to be in the context of that DB
That is, the following will throw an error:
DBCC CHECKIDENT ([MyDataBase].[MySchemaName].[MyTable], RESEED, 0)
Enclose the fully-qualified table name with single quotes instead:
DBCC CHECKIDENT ('[MyDataBase].[MySchemaName].[MyTable]', RESEED, 0)
Several answers recommend using a statement something like this:
DBCC CHECKIDENT (mytable, RESEED, 0)
But the OP said "deleted some records", which may not be all of them, so a value of 0 is not always the right one. Another answer suggested automatically finding the maximum current value and reseeding to that one, but that runs into trouble if there are no records in the table, and thus max() will return NULL. A comment suggested using simply
DBCC CHECKIDENT (mytable)
to reset the value, but another comment correctly stated that this only increases the value to the maximum already in the table; this will not reduce the value if it is already higher than the maximum in the table, which is what the OP wanted to do.
A better solution combines these ideas. The first CHECKIDENT resets the value to 0, and the second resets it to the highest value currently in the table, in case there are records in the table:
DBCC CHECKIDENT (mytable, RESEED, 0)
DBCC CHECKIDENT (mytable)
As multiple comments have indicated, make sure there are no foreign keys in other tables pointing to the deleted records. Otherwise those foreign keys will point at records you create after reseeding the table, which is almost certainly not what you had in mind.
I want to add this answer because the DBCC CHECKIDENT-approach will product problems when you use schemas for tables. Use this to be sure:
DECLARE #Table AS NVARCHAR(500) = 'myschema.mytable';
DBCC CHECKIDENT (#Table, RESEED, 0);
If you want to check the success of the operation, use
SELECT IDENT_CURRENT(#Table);
which should output 0 in the example above.
You do not want to do this in general. Reseed can create data integrity problems. It is really only for use on development systems where you are wiping out all test data and starting over. It should not be used on a production system in case all related records have not been deleted (not every table that should be in a foreign key relationship is!). You can create a mess doing this and especially if you mean to do it on a regular basis after every delete. It is a bad idea to worry about gaps in you identity field values.
What about this?
ALTER TABLE `table_name`
MODIFY `id` int(12) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=0;
This is a quick and simple way to change the auto increment to 0 or whatever number you want. I figured this out by exporting a database and reading the code myself.
You can also write it like this to make it a single-line solution:
ALTER TABLE `table_name` MODIFY `id` int(12) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=0;
To reset every key in the database to autoincrement from the max of the last highest key:
Exec sp_MSforeachtable 'DBCC CHECKIDENT(''?'', RESEED, 0)'
Exec sp_MSforeachtable 'DBCC CHECKIDENT(''?'', RESEED)'
If you just want to reset the primary key/sequence to start with a sequence you want in a SQL server, here's the solution -
IDs:
99 100 101 1200 1201...
Drop rows with IDs >= 1200. (Be careful if you have foreign key constraints tied to these which has to be dealed with or deleted too to be able to delete this.)
Now you want to make sure you know the MAX ID to be sure:
declare #max_id as int = (SELECT MAX(your_column_name) FROM
your_table)+1;
(Note: +1 to start the ID sequence after max value)
Restart your sequence:
exec('alter sequence your_column_name restart with ' + #max_id);
(Note: Space after with is necessary)
Now new records will start with 102 as the ID.
I know this is an old question. However, I was looking for a similar solution for MySQL and this question showed up.
for those who are looking for MySQL solution, you need to run this query:
// important!!! You cannot reset the counter to a value less than or equal to the value that is currently in use. For both InnoDB and MyISAM, if the value is less than or equal to the maximum value currently in the AUTO_INCREMENT column, the value is reset to the current maximum AUTO_INCREMENT column value plus one.
ALTER TABLE <your-table-name> AUTO_INCREMENT = 100
documentation