Self joins and Not in combined - sql

Question

I need to write a query scanning 2 tables in a way that the record after self join in one table should not be present in second table if they have certain condition.
If an order is received we insert into UniqueReference Table that has unique constraints on reference combination (data1,data2,reference,identifier)
But it could be that order get Rejected or Cancelled and next order might come with same reference combination. I have to make sure I still allow it.
I give an example below for test data :
UniqueReference Table
-------
sequence data1 data2 key reference identifier
1 XYZB ABCD 234 Reference1 ID2
2 XYZB DCBF 456 Reference2 ID2
3 XYZB null 678 Reference3 null
4 XYZB ABCD 980 Reference1 ID2
Order Table
--------
sequence key status
1 234 Created
2 456 Rejected
3 789 Processed
4 980 Cancelled
5 678 Processing
Now with above two data set when I receive an order (so say key 980) with reference combination (XYZB,ABCD,Reference1,ID2) then system should not allow that order (it is duplicate) because earlier we received such order with key (234) whose status is not Rejected. But if we receive new order with combination (XYZB,DCBF,Reference2,ID2) then we should allow this order because we do have that order in system but its status is Rejected.
I am needing something like
Select count(*) from Order o where o.status <> 'Rejected' and o.key in
(select <self-join> on reference combination on key for newly received order)

Answer 1

I think you're mostly confusing yourself with this setup.
As for the UniqueReference table. If you say the combination data1, data2, reference, identifier is UNIQUE, well, then it should be just that: UNIQUE. It doesn't matter nor should care about what happens elsewhere.
Remark: I'm assuming the key field is unique too, and if it is, I do wonder why you don't simply use the autonumber/identity/... for it which you now seem to assign to the sequence column, which has no real value IMHO. Right now I can't tell how you produced these key values.
Now for the Order table, here you could foresee logic that says: if we don't have a previous record for this key yet, allow INSERT operation. If there is a previous one, find the most recent one and if it says 'Cancelled' then allow the INSERT too. Otherwise we always block the INSERT.
I'm not sure how you would like to do this, but I guess a stored procedure would make sense in this case.
PS: this code is far from perfect (for starters, it's NOT tested!), has no error-handling and probably can be optimized quite a bit (e.g. by merging certain operations, less branching, etc). But I think its verbosity makes it easier to read and since premature optimization is the root of all evil you might want to work it out like this first and optimize as needed when it turns out to be too slow.
(since you didn't mention RDBMS, I'm using T-SQL syntax, but I think it is sufficiently generic to run on most systems with minor tweaking...)
CREATE PROCEDURE p_insert_order (
#data1 varchar(100),
#data2 varchar(100),
#reference varchar(100),
#identifier varchar(100),
#status varchar(100)
)
AS
DECLARE #key int,
#is_new_key bit,
#allow_insert bit,
#last_status varchar(100)
SELECT #key = NULL,
#is_new_key = 0,
#allow_insert = 0,
#last_status = NULL
BEGIN TRANSACTION
-- do we already have a key for this combination?
SELECT #key = [key]
FROM [UniqueReference] WITH (UPDLOCK, HOLDLOCK)
WHERE data1 = #data1
AND data2 = #data2
AND reference = #reference
AND identifier = #identifier
IF #key IS NULL
BEGIN
SELECT #is_new_key = 1,
#key = 0 -- ??? -- I have no clue how you come up with these so I'm going to leave it open
INSERT [UniqueReference] (data1, data2, reference, identifier, [key])
VALUES (#data1, #data2, #reference, #identifier, #key)
END
-- do we allow insert?
SELECT #allow_insert = #is_new_key
IF #allow_insert = 0
BEGIN
SELECT TOP 1 #last_status = [status]
FROM [Order] WITH (UPDLOCK, HOLDLOCK)
WHERE [key] = #key
ORDER BY sequence DESC
SELECT #allow_insert = 1
WHERE #last_status IS NULL
OR #last_status = 'Rejected'
END
-- do we do insert?
IF #allow_insert = 1
BEGIN
INSERT [Order] ([key], [status])
VALUES (#key, #status)
END
COMMIT TRANSACTION
Return(0)
PS: Try to avoid using reserved words, Order, key, status, ...

Answer 2

First of all you have to add key column in UniqueReference table to the unique constraint so it will be (data1,data2,reference,identifier,key)
Then you can use this query
;with
old_orders as (
select distinct data1, data2, [reference], [identifier]
from UniqueReference u
where not exists(select top 1 1 from Order o where u.[key] = o.[key] and o.status in ('Cancelled','Rejected'))
)
insert into #UniqueReference (data1, data2, [reference], [identifier], [key])
select #data1, #data2, #reference, #identifier, #key
where exists (
select #data1, #data2, #reference, #identifier
except
select * from old_orders o
)
With these values the insert will be rejected
declare
#data1 varchar(4)='XYZB',
#data2 varchar(4)='ABCD',
#key int = 980,
#reference varchar(10)='Reference1',
#identifier varchar(4)='ID2'
With these values the insert will be accepted
declare
#data1 varchar(4)='XYZB',
#data2 varchar(4)='DCBF',
#key int = 999,
#reference varchar(10)='Reference2',
#identifier varchar(4)='ID2'