Performance issues generating a unique name - sql

Question

I have a table 'Objects' present in SQL Server DB. It contains the names (string) of objects.
I have a list of names of new objects that need to be inserted in the 'Objects' table, in a separate table 'NewObjects'. This operation will be referred as 'import' henceforward.
I need to generate a unique name for each record to be imported to 'Objects' from 'NewObjects', if the record name is already present in 'Objects'. This new name will be stored in 'NewObjects' table against the old name.
DECLARE #NewObjects TABLE
(
...
Name varchar(20),
newName nvarchar(20)
)
I have implemented a stored procedures which generates unique name for each record to be imported from 'NewObjects'. However, I am not happy with the performance for 1000 records (in 'NewObjects'.)
I want help to optimize my code. Below is the implementation:
PROCEDURE [dbo].[importWithNewNames] #args varchar(MAX)
-- Sample of #args is like 'A,B,C,D' (a CSV string)
...
DECLARE #NewObjects TABLE
(
_index int identity PRIMARY KEY,
Name varchar(20),
newName nvarchar(20)
)
-- 'SplitString' function: this is a working implementation which is right now not concern of performance
INSERT INTO #NewObjects (Name)
SELECT * from SplitString(#args, ',')
declare #beg int = 1
declare #end int
DECLARE #oldName varchar(10)
-- get the count of the rows
select #end = MAX(_index) from #NewObjects
while #beg <= #end
BEGIN
select #oldName = Name from #NewObjects where #beg = _index
Declare #nameExists int = 0
-- this is our constant. We cannot change
DECLARE #MAX_NAME_WIDTH int = 5
DECLARE #counter int = 1
DECLARE #newName varchar(10)
DECLARE #z varchar(10)
select #nameExists = count(name) from Objects where name = #oldName
...
IF #nameExists > 0
BEGIN
-- create name based on pattern 'Fxxxxx'. Example: 'F00001', 'F00002'.
select #newName = 'F' + REPLACE(STR(#counter, #MAX_NAME_WIDTH, 0), ' ', '0')
while EXISTS (select top 1 1 from Objects where name = #newName)
OR EXISTS (select top 1 1 from #NewObjects where newName = #newName)
BEGIN
select #counter = #counter + 1
select #newName = 'F' + REPLACE(STR(#counter, #MAX_NAME_WIDTH, 0), ' ', '0')
END
select top 1 #z = #newName from Objects
update #NewObjects
set newName = #z where #beg = _index
END
select #beg = #beg + 1
END
-- finally, show the new names generated
select * from #NewObjects

Answer 1

DISCLAIMER: I am in no position to test these recommendations therefore there may be syntax errors that you'll have to work out on your own as you implement them. They are here as a guide to both fix this procedure but also aid you in growing your skill set for future projects.
One optimization just skimming through, that would become more prevalent as you iterated over larger sets, is this code here:
select #nameExists = count(name) from Objects where name = #oldName
...
IF #nameExists > 0
consider changing it to this:
IF EXISTS (select name from Objects where name = #oldName)
Also, rather than doing this:
-- create name based on pattern 'Fxxxxx'. Example: 'F00001', 'F00002'.
select #newName = 'F' + REPLACE(STR(#counter, #MAX_NAME_WIDTH, 0), ' ', '0')
while EXISTS (select top 1 1 from Objects where name = #newName)
OR EXISTS (select top 1 1 from #NewObjects where newName = #newName)
BEGIN
select #counter = #counter + 1
select #newName = 'F' + REPLACE(STR(#counter, #MAX_NAME_WIDTH, 0), ' ', '0')
END
consider this:
DECLARE #maxName VARCHAR(20)
SET #newName = 'F' + REPLACE(STR(#counter, #MAX_NAME_WIDTH, 0), ' ', '0')
SELECT #maxName = MAX(name) FROM Objects WHERE name > #newName ORDER BY name
IF (#maxName IS NOT NULL)
BEGIN
#counter = CAST(SUBSTRING(#maxName, 2) AS INT)
SET #newName = 'F' + REPLACE(STR(#counter, #MAX_NAME_WIDTH, 0), ' ', '0')
END
that will ensure that you're not iterating and doing multiple queries just to find the maximum integer value of the generated name.
Further, based on what little context I have, you should also be able to make one more optimization that will ensure you only have to do the aforementioned one time, ever.
DECLARE #maxName VARCHAR(20)
SET #newName = 'F' + REPLACE(STR(#counter, #MAX_NAME_WIDTH, 0), ' ', '0')
IF (#beg = 1)
BEGIN
SELECT #maxName = MAX(name) FROM Objects WHERE name > #newName ORDER BY name
IF (#maxName IS NOT NULL)
BEGIN
#counter = CAST(SUBSTRING(#maxName, 2) AS INT)
SET #newName = 'F' + REPLACE(STR(#counter, #MAX_NAME_WIDTH, 0), ' ', '0')
END
END
The reason I say you can make that optimization is because unless you have to worry about other entities inserting records during this time that look like the ones you are (e.g. Fxxxxx), then you only have to find the MAX one time and can simply iterate #counter over the loop.
In fact, you could actually pull this entire piece out of the loop. You should be able to extrapolate that pretty easily. Just pull the DECLARE and SET of #counter out along with the code inside the IF (#beg = 1). But take it one step at a time.
Also, change this line:
select top 1 #z = #newName from Objects
to this:
SET #z = #newName
because you are literally running a query to SET two local variables. This is likely a huge cause for the performance issues. A good practice for you to get into is unless you're actually setting a variable from a SELECT statement, use the SET operation for local variables. There are some other places in your code where this applies, consider this line:
select #beg = #beg + 1
use this instead:
SET #beg = #beg + 1
Finally, as stated above regarding simply iterating #counter, at the end of the loop where you have this line:
select #beg = #beg + 1
just add a line:
SET #counter = #counter + 1
and you're golden!
So to recap, you can gather the maximum conflicting name just one time so you'll be getting rid of all those iterations. You're going to start using SET to get rid of performance ridden lines like select top 1 #z = #newName from Objects where you're actually querying a table to set two local variables. And you're going to leverage the EXISTS method instead of setting a variable that leveraged an AGGREGATE function COUNT to do that work.
Let me know how these optimizations work.

Answer 2

You should avoid queries inside loops.. Especially if this is in a table variable...
You should try to use a temp table and index this table on newname column. I bet it would improve a bit the performance..
But would be better you rewrite it all avoiding those loop with query inside..
Setting my ambient for test...
--this would be your object table... I feed it with some values for test
DECLARE #Objects TABLE
(
_index int identity PRIMARY KEY,
Name varchar(20)
)
insert into #Objects(name)
values('A'),('A1'),('B'),('F00001')
--the parameter of your procedure
declare #args varchar(MAX)
set #args = 'A,B,C,D,F00001'
--#NewObjects2 is your #NewObjects just named the n2 cause I did run your solution together when testing
DECLARE #NewObjects2 TABLE
(
_index int identity PRIMARY KEY,
Name varchar(20),
newName nvarchar(20)
)
INSERT INTO #NewObjects2 (Name)
SELECT * from SplitString(#args, ',')
declare #end int
select #end = MAX(_index) from #NewObjects2
DECLARE #MAX_NAME_WIDTH int = 5
At this point its very similar your solution
Now what I would do instead your looping
--generate newNames in format FXXXXX with free names sufficient to give newnames for all lines in #newObject
--you should alter this to get the greater FXXXXX name inside the Objects and start generate newNames from this point.. to avoid overhead creating newNames that will sure not to be used..
with N_free as
(
select
0 as [count],
'F' + REPLACE(STR(0, #MAX_NAME_WIDTH, 0), ' ', '0') as [newName],
0 as fl_free,
0 as count_free
union all
select
N.[count] + 1 as [count],
'F' + REPLACE(STR(N.[count]+1, #MAX_NAME_WIDTH, 0), ' ', '0') as [newName],
OA.fl_free,
count_free + OA.fl_free as count_free
from
N_free N
outer apply
(select
case
when not exists(select name from #Objects
where Name = 'F' + REPLACE(STR(N.[count]+1, #MAX_NAME_WIDTH, 0), ' ', '0'))
then 1
else 0
end as fl_free) OA
where
N.count_free < #end
)
--return only those newNames that are free to be used
,newNames as (select ROW_NUMBER() over (order by [count]) as _index_name
,[newName]
from N_free where fl_free = 1
)
--update the #NewObjects2 giving newname for the ones that got the name already been used on Objects
update N2
set newName = V2.[newName]
from #NewObjects2 N2
inner join (select V._index,V.Name,newNames.[newName]
from( select row_number() over (partition by case when O.Name is not null
then 1
else 0
end
order by N._index) as _index_name
,N._index
,N.Name
,case when O.Name is not null
then 1
else 0
end as [fl_need_newName]
from #NewObjects2 N
left outer join #Objects O
on O.Name = N.Name
)V
left outer join newNames
on newNames._index_name = V._index_name
and V.fl_need_newName = 1
)V2
on V2._index = N2._index
option(MAXRECURSION 0)
select * from #NewObjects2
The results that I achieved was the same then using your solution for this ambient...
You may check if this really generate same result...
The result for this query was
_index Name newName
1 A F00002
2 B F00003
3 C NULL
4 D NULL
5 F00001 F00004