Optimize Dedup TSQL?

The following is fairly basic cursor based merge code. Order by UserName and DomainID; INSERT a single merged record for every distinct combination.

I had originally written this as a single INSERT statement with subqueries. Avoiding cursors is supposed to be faster but comparing the execution plans for both strategies suggested the cursor based code was MUCH faster, so this is what I'm going to try and use.

If anyone can think of any optimizations to this I would be very grateful. Thanks!


DECLARE @emailUser VARCHAR(50)
DECLARE @domainID INT
DECLARE @firstName VARCHAR(24)
DECLARE @lastName VARCHAR(24)
DECLARE @streetAddress VARCHAR(32)
DECLARE @city VARCHAR(24)
DECLARE @state VARCHAR(24)
DECLARE @postal VARCHAR(10)
DECLARE @sourceID INT
DECLARE @numNameNULLs INT
DECLARE @numAddressNULLs INT

DECLARE @rowEmailUser VARCHAR(50)
DECLARE @rowDomainID INT
DECLARE @rowFirstName VARCHAR(24)
DECLARE @rowLastName VARCHAR(24)
DECLARE @rowStreetAddress VARCHAR(32)
DECLARE @rowCity VARCHAR(24)
DECLARE @rowState VARCHAR(24)
DECLARE @rowPostal VARCHAR(10)
DECLARE @rowSourceID INT
DECLARE @rowNumNameNULLs INT
DECLARE @rowNumAddressNULLs INT

DECLARE stagingCursor CURSOR FOR
SELECT
UserName, DomainID, First, Last, StreetAddress, City, State, Postal, SourceID
, (CASE WHEN Stages.[First] IS NULL THEN 1 ELSE 0 END
+ CASE WHEN Stages.[Last] IS NULL THEN 1 ELSE 0 END) AS NumNameNULLs
,(CASE WHEN Stages.[StreetAddress] IS NULL THEN 1 ELSE 0 END
+ CASE WHEN Stages.[City] IS NULL THEN 1 ELSE 0 END
+ CASE WHEN Stages.[State] IS NULL THEN 1 ELSE 0 END
+ CASE WHEN Stages.[Postal] IS NULL THEN 1 ELSE 0 END) AS NumAddressNULLs
FROM Stages
WHERE NOT EXISTS
(SELECT UserName FROM Recipients
WHERE Stages.UserName = Recipients.UserName
AND Stages.DomainID = Recipients.DomainID)
ORDER BY UserName, DomainID

OPEN stagingCursor
FETCH NEXT FROM stagingCursor INTO
@rowEmailUser, @rowDomainID, @rowFirstName, @rowLastName, @rowStreetAddress, @rowCity, @rowState, @rowPostal, @rowSourceID, @rowNumNameNULLs, @rowNumAddressNULLs
WHILE @@FETCH_STATUS = 0
BEGIN
IF (@emailUser = @rowEmailUser AND @domainID = @rowDomainID) BEGIN
-- Merge a consecutive row for the current UserName/DomainID combination
IF (@rowNumNameNULLs < @numNameNULLs) BEGIN
SET @numNameNULLs = @rowNumNameNULLs
SET @firstName = @rowFirstName
SET @lastName = @rowLastName
END
IF (@rowNumAddressNULLs < @numAddressNULLs) BEGIN
SET @streetAddress = @rowStreetAddress
SET @city = @rowCity
SET @state = @rowState
SET @postal = @rowPostal
SET @numAddressNULLs = @rowNumAddressNULLs
END
END ELSE BEGIN
IF (@emailUser IS NOT NULL) BEGIN
-- Finished iterating 1+ records of a UserName/DomainID combination. INSERT the merged record.
INSERT INTO Recipients(UserName, DomainID, First, Last, StreetAddress, City, State, Postal, SourceID)
VALUES (@emailUser, @domainID, @firstName, @lastName, @streetAddress, @city, @state, @postal, @sourceID)
END

-- Reached a new UserName/DomainID combination. Set current data.
SET @emailUser = @rowEmailUser
SET @domainID = @rowDomainID
SET @firstName = @rowFirstName
SET @lastName = @rowLastName
SET @streetAddress = @rowStreetAddress
SET @city = @rowCity
SET @state = @rowState
SET @postal = @rowPostal
SET @sourceID = @rowSourceID
SET @numNameNULLs = @rowNumNameNULLs
SET @numAddressNULLs = @rowNumAddressNULLs
END

FETCH NEXT FROM stagingCursor INTO
@rowEmailUser, @rowDomainID, @rowFirstName, @rowLastName, @rowStreetAddress, @rowCity, @rowState, @rowPostal, @rowSourceID, @rowNumNameNULLs, @rowNumAddressNULLs
END
CLOSE stagingCursor
DEALLOCATE stagingCursor

IF (@emailUser IS NOT NULL) BEGIN
-- Finished iterating 1+ records of a UserName/DomainID combination. INSERT the merged record.
INSERT INTO Recipients(UserName, DomainID, First, Last, StreetAddress, City, State, Postal, SourceID)
VALUES (@emailUser, @domainID, @firstName, @lastName, @streetAddress, @city, @state, @postal, @sourceID)
END


A coworker has a C++ solution that uses FAST INSERT operations (directly through the ADODB API; like bcp or BULK INSERT). He claims to get twice the performance over the above T-SQL although I can't use his application due to bizarre errors. The above T-SQL is obviously using plain old INSERT statements although I hope the looping and everything would be faster since its 100% native database code. Is there anyway I can get FAST/BULK INSERT like performance through the above T-SQL?