Question

I have a SQL Server table:

+----+-------------+-------------------+
| ID | CompanyID   | CompanyCode       |
+----+-------------+-------------------+
| 1  | 1           | AAAA-123          |
| 2  | 2           | BBBB-111          |
| 3  | 1           | AAAA-123          |
| 4  | 3           | CCCC-999          |
| 5  | 3           | CCCC-999          |
| 6  | 1           | AAAA-123          |
+----+-------------+-------------------+

The ID field is the PK.

The CompanyID and CompanyCode fields specify a unique company whereby a CompanyID will ALWAYS have the same CompanyCode (and vice versa) and no two Companies will ever have the same CompanyID and/or CompanyCode.

I would like to create a rule on the table that will never allow a record to be added to the table if/when a CompanyCode doesn’t match an existing CompanyCode where the CompanyID‘s match.

The following is an example of what I cannot allow to occur on the table:

+----+-------------+-------------------+
| ID | CompanyID   | CompanyCode       |
+----+-------------+-------------------+
| 1  | 1           | AAAA-123          |
| 2  | 1           | BBBB-111          |<<<< This record should not be allowed
| 3  | 1           | AAAA-123          |
| 4  | 3           | CCCC-999          |
| 5  | 3           | CCCC-999          |
| 6  | 1           | AAAA-123          |
+----+-------------+-------------------+

Notice the record with ID=2, the CompanyCode BBBB-111 doesn’t match the existing record that has a CompanyCode of AAAA-123.

I want this rule to exist on the table somehow – i.e. I don’t want this rule to be a business rule that queries and/or stored procedures have to manage.

I suppose you can say I’m wanting to enforce duplicate records (on CompanyID and CompanyCode) if and only if an existing CompanyID and/or CompanyCode exists in the table.

Is this possible to do at the table design level? Or am I stuck with having to manage this in my scripts?

Update

Although this isn’t really pertinent to my OP, from the feedback I received, I suppose I should give a little background on the CompanyID/CompanyCode table design.

First off, this is just a mock table design to try to explain my question – my real table has nothing to do with companies.

Second, my real table is a middle-man between two web-services where Service1 creates a DeviceID and Service2 collects a SerialNumber that exists in a micro-device. Also, my real table contains many other columns that this middle-man server has to process.

One of the strange things about this middle-man service is that the table that I’m talking about has to allow NULLS for both the DeviceID and SerialNumber – it all depends on which Service sent a record first…. I’m am talking too much and going way off topic of my original question, but I thought I had to clarify my table example since I was getting much flak in regards to my breaking normalization.

Answer 1

Okay, this isn’t the prettiest of code, but it does enforce the constraint, I think. The trick is to create an indexed view with two unique indexes defined on it:

create table dbo.ABC (
    Col1 int not null,
    Col2 int not null
)
go
create view dbo.ABC_Col1_Col2_dep
with schemabinding
as
    select Col1,Col2,COUNT_BIG(*) as Cnt
    from
        dbo.ABC
    group by
        Col1,Col2
go
create unique clustered index IX_Col1_UniqueCol2 on dbo.ABC_Col1_Col2_dep (Col1)
go
create unique nonclustered index IX_Col2_UniqueCol1 on dbo.ABC_Col1_Col2_dep (Col2)
go

Now we insert some initial data:

insert into dbo.ABC (Col1,Col2)
select 1,3 union all
select 2,19 union all
select 3,12

We can add another row with exactly the same values for Col1 and Col2:

insert into dbo.ABC (Col1,Col2)
select 1,3

But if we pick a value for Col2 that has been used for another Col1, or vice versa, we get errors:

insert into dbo.ABC (Col1,Col2)
select 2,3
go
insert into dbo.ABC (Col1,Col2)
select 1,5

---

The trick here was to observe that this query:

    select Col1,Col2,COUNT_BIG(*) as Cnt
    from
        dbo.ABC
    group by
        Col1,Col2

will only have one row for a particular Col1 value, and only one row with a particular Col2 value, provided that the constraint you’re seeking to enforce has not been broken – but as soon as a non-matching row is inserted into the base table, this query returns multiple rows.