Question

I use SQL Server 2008 R2.

I’m looking for a feature that I describe as dependent identity.

I’ll explain by an example.

consider a table like this one:

script

CREATE TABLE [dbo].[Rooms](
    [RoomID] [int] NOT NULL,
    [ItemID] [int] NOT NULL,
    [ItemDescription] [nvarchar] (250))
GO

data:

RoomID  ItemID  ItemDescription
------  ------  --------------- 
7       1       Door
7       2       Window (West)
7       3       Window (North)
8       1       Door
8       2       Table #1
8       3       Table #2
7       4       Table #1 
8       4       Chair #1 
7       5       Table #2 
7       6       Table #3 
8       5       Chair #2

(can anyone tell the secret how to format an example table here?)

I would have love to be able to declare a dependent identity column like this:

ItemID [int] Identity(RoomID,1,1) NOT NULL

A new row in [Rooms] should triggers a test for the max value of ItemID where RoomID = @roomID and add 1.

Instead of update with a change in RoomID use delete and insert the required data.

Nowadays I do that programmatically like this:

DECLARE @roomID INT
SET @roomID = 7
INSERT INTO [Allocation].[dbo].[Rooms]
    ([RoomID], [ItemID], [ItemDescription]) VALUES (@roomID,
    (SELECT max([ItemID])+1 FROM [Allocation].[dbo].[Rooms] WHERE [RoomID]=@roomID)
    ,'Chair #1')
GO

So, Is there such a feature?

In the probable case there is none, could I program the server to set next dependent identity for me automatically, given a specific table, parent column and dependent identity column?

Answer 1

You can use a trigger, and an index to improve performance and ensure there are no duplicates.

Change your table to have a primary key, and allow null for ItemID

CREATE TABLE [dbo].[Rooms](
    [RoomID] [int] NOT NULL,
    [ItemID] [int] NULL,
    [ItemDescription] [nvarchar](250) NULL,
    [Id] [int] IDENTITY(1,1) NOT NULL,
    CONSTRAINT [PK_Rooms] PRIMARY KEY CLUSTERED 
    (
        [Id] ASC
    )
)

and then add a trigger

CREATE TRIGGER RoomTrigger
   ON  Rooms
   AFTER INSERT
AS 
BEGIN
    SET NOCOUNT ON;

    update Rooms
    set 
        ItemID = (select coalesce(MAX(itemid), 0) + 1 
                      from Rooms r where r.RoomID = inserted.RoomID )
    from
        inserted where Rooms.Id = inserted.Id

END

Then you can do this

insert into Rooms (RoomID, ItemDescription) values (1, 'Test')
insert into Rooms (RoomID, ItemDescription) values (1, 'Test')

which results in

RoomID  ItemID ItemDescription Id
2       0      Test            1
2       1      Test            2

As suggested by marc_s I’ve used SQL Query Stress with 10 threads to see what happens with this trigger under load. I didn’t get any duplicates at all (using the default isolation level), but I did get loads of deadlocks as I would have expected.

Using the original query from the question I get a lot of duplicates.

Using the trigger approach I get deadlocks and results like this:

RoomID ItemID ItemDescription Id
1      6      Test            6
1      7      Test            9
1      8      Test            902
1      9      Test            903

Here ItemID is contiguous, but about 900 out of 1000 rows failed to be inserted leaving large gaps in Id.

If we add the following index:

CREATE UNIQUE NONCLUSTERED INDEX [IX_Rooms] ON [dbo].[Rooms] 
(
    [RoomID] ASC,
    [ItemID] ASC
)

in order to guarantee no duplicates, and improve the performance of calculating Max(ItemId) for a particular RoomID, then now:

• the original query from the question causes duplicates and only manages to insert 500 rows.
• the trigger version using the default isolation level succeeds without any deadlocks or errors and runs very fast.

Using the trigger with isolation level = serializable brings back deadlocks so only 40% of the inserts succeed (but no exceptions due to duplicates).

As a final test tried with trigger + 50 threads + isolation level = default. No errors.