T-sql, finding elements not matched from list of keys - sql-server

Question

SQL Fiddle: http://sqlfiddle.com/#!6/52c67/1
CREATE TABLE MailingList (EmployeeId INT, Email VARCHAR(50))
INSERT INTO MailingList VALUES (1, 'bob#co.com')
INSERT INTO MailingList VALUES (2, 'jill#co.com')
INSERT INTO MailingList VALUES (3, 'frank#co.com')
INSERT INTO MailingList VALUES (4, 'fred#co.com')
Now I get a list of EmployeeIds from somewhere: 1,2,3,4,5
I need to check which of these employeeIds are NOT in the Mailinglist table. I expect to get the result "5" in this case, as it is NOT in the mailinglist table.
What is the easiest way to do this?
Is there an easier way than generating a temporary table, inserting the values 1,2,3,4,5 and then doing either a select ... where not in (select ...) - or getting the same with doing a join. So basically without creating a temporary table and insert the data, but just working with the list 1,2,3,4,5.

Answer 1

Everyone is on the right track here with the idea of an ANTI JOIN. It's worth noting however, that the answers proposed will not always produce the exact same results and each solution has different performance implications. What MatBailie is proposing is how to do an ANTI JOIN, What Alexander is proposing is how to do an ANTI SEMI JOIN.
Alexander is more on the right track IMO as what we're looking for is an ANTI SEMI JOIN; a LEFT ANTI SEMI JOIN, to be specific, with your list of employeeIds from "somewhere" as the Left table and MailingList as the Right table.
An ANTI JOIN returns records that exist in this set that don't exist in that set. By set I'm referring to a table, view, subquery, etc. By "this" set I'm referring to the LEFT table and by "that" set I'm referring to RIGHT table. A SEMI JOIN is where only one matching row from the LEFT table is returned. In other words, A SEMI join returns a distinct set.
Now I get a list of EmployeeIds from somewhere
Using the sample data provided. Let's say that, by "somewhere" you are talking about a table. (I'm including the number 5 twice to demonstrate the difference between and ANTI JOIN and ANTI SEMI JOIN)
CREATE TABLE dbo.somewhere (employeeId int);
INSERT dbo.somewhere VALUES (1),(2),(3),(4),(5),(5);
You could do a LEFT ANTI JOIN using NOT IN or NOT EXISTS
-- ANTI JOIN USING NOT IN
SELECT somewhere.EmployeeId--, <other columns>
FROM dbo.somewhere
WHERE somewhere.EmployeeId NOT IN (SELECT EmployeeId FROM dbo.MailingList); -- EXLCLUDE IDs NOT IN MailingList
-- ANTI JOIN USING NOT EXISTS
SELECT somewhere.EmployeeId--, <other columns>
FROM dbo.somewhere
WHERE NOT EXISTS
(
SELECT EmployeeId
FROM dbo.MailingList ML
WHERE ML.EmployeeId = somewhere.employeeId
);
Note that Each of these return the number 5 twice. If you only needed it once you would use EXCEPT to perform an ANTI SEMI JOIN like so:
SELECT somewhere.EmployeeId
FROM dbo.somewhere
EXCEPT -- SET OPERATOR (SET OPERATORS INCLUDE: UNION, UNION ALL, EXCEPT, INTERSECT)
SELECT EmployeeId
FROM dbo.MailingList; -- EXLCLUDE IDs NOT IN MailingList
EXCEPT is a Set Operator like UNION and INTERSECT. Set operators return a unique result set. (The one exception to this being UNION ALL). If you wanted a unique result set using NOT IN or NOT EXISTS you would also need to include DISTINCT or GROUP BY all the columns which you want to be unique.
If by "somewhere" you are talking about a comma-delimited list or XML or JSON file/fragment then you would first need to turn that list, XML, JSON or whatever into the LEFT table. Using SQL Server 2016's string_split (or another "splitter" function) you would do this:
-- "somewhere" is a csv, list or array
DECLARE #somewhere varchar(1000) = '1,2,3,4,5';
-- ANTI JOIN WITH NOT IN
SELECT EmployeeId = [value]
FROM string_split(#somewhere, ',')
WHERE [value] NOT IN (SELECT EmployeeId FROM dbo.MailingList);
-- ANTI SEMI JOIN WITH NOT IN
SELECT DISTINCT EmployeeId = [value]
FROM string_split(#somewhere, ',')
WHERE [value] NOT IN (SELECT EmployeeId FROM dbo.MailingList);
-- ANTI SEMI JOIN WITH EXCEPT
SELECT EmployeeId = [value]
FROM string_split(#somewhere, ',')
EXCEPT
SELECT EmployeeId FROM dbo.MailingList;
GO
.. or if it were XML, one option would look like this:
-- "somewhere" is XML
DECLARE #somewhere XML =
'<employees>
<employee>1</employee>
<employee>2</employee>
<employee>3</employee>
<employee>4</employee>
<employee>5</employee>
</employees>'
-- ANTI SEMI JOIN using EXCEPT
SELECT employeeId = emp.id.value('.', 'int')
FROM (VALUES (#somewhere)) s(empid)
CROSS APPLY empid.nodes('/employees/employee') emp(id)
EXCEPT
SELECT employeeId
FROM dbo.MailingList;
Lastly. You want an index on EmployeeId in your mailing list table. In my examples you would want an index on dbo.somewhere as well. If you are doing SEMI joins then you want those indexes to be unique.

Answer 2

You can use EXCEPT command.
Example:
SELECT *
FROM
(
SELECT 1 AS Id
UNION ALL SELECT 2
UNION ALL SELECT 3
UNION ALL SELECT 4
UNION ALL SELECT 5
) AS t
EXCEPT
SELECT Id FROM MailingList

Answer 3

You don't seem to be asking about the logic, just about how to "best" represent the set {1,2,3,4,5}.
One answer is a temporary table, as you mentioned.
Another is a sub-query or a CTE with a bunch of UNION ALL statements.
Another would be to use VALUES (1), (2), (3), (4), (5) in either a CTE or sub-query.
But there is a glaring point here. If you have a table with an EmployeeID field, then surely you have an Employee table? That being the case you should be able to "derive" your set of 5 employees from there?
(SELECT id FROM employee WHERE manager_id = 666)
or...
(SELECT id FROM employee WHERE staff_ref IN ('111', '222', '333', '444', '555'))
etc, etc...
EDIT:
As for the actual logic once you have your set representing your 5 employees, you can do an "anti-join" using LEFT JOIN and IS NULL...
SELECT
Employee.*
FROM
Employee
LEFT JOIN
MailingList
ON MailingList.list_id = 789
AND MailingList.employee_id = Employee.id
WHERE
Employee.manager_id = 666
AND MailingList.employee_id IS NULL
=> Employees with manager #666 but not on mailing list #789