Generating/updating unique random barcode numbers in a column in SQL - sql

Question

We're a manufacturing company, and I have a SQL Table [FSDBGL] that holds information for every item we have. This includes columns for ItemNumber, ItemUPC, and ItemStatus. Some of the data in the ItemUPC column is empty for required items.
What I need to do, is assign/insert a random unique barcode number (that isn't already taken) inside of the ItemUPC column. The number needs to be 12 digits long, and be preceded with "601040xxxxxx", randomizing only the last 6 digits. This does not have to be done on every row for every item number.
-- Check/update only the [ItemNumber]'s (between 40000-01 - 50000-01) (the -01 at the end could also be a -02)
I need to ignore/exclude the following column attributes from getting a number:
-- ItemStatus (only if it's set at 'O' for Obsolete)
-- ItemUPC (if it already has a barcode number)
I would like to customize a SQL query for this that I can populate the cells now, and implement into a nightly process to update any newly-created Item#'s as well.
Here's the CREATE Script view:
USE [FSDBGL]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[Mfg_ITMMAST](
[IMPN] [varchar](30) NOT NULL,
[IMDESC] [varchar](70) NOT NULL,
[IMUPCCD] [varchar](13) NOT NULL,
) ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO

Answer 1

Random numbers: You could loop through each row that's missing the UPC using a cursor and get a random number for each one using ROUND(RAND() * 999999,0, 0), and then check for collisions before doing the update. The where clause for the cursor query should be pretty straightforward... regular expression on the ItemNumber, ItemStatus != 'O', ItemUPC != null or '' or 0 (or whatever the default value is).
The sproc should be rerunnable at any time, since it uses random numbers and checks for collisions.
A more efficient way would be to use serial-issued numbers instead of random. As long as you were able to store the last used number in a table somewhere, I believe you could add all the UPC numbers with one query instead of having to run several for each one by utilizing the UPDATE ... FROM syntax and the SELECT #counter = #counter + 1 syntax for user variables.
EDIT: Adding stored procedure and other comments
Let me first note that this database design is probably not optimal. There is no primary key on this table and no indexes. If this table has any large amount of records, queries are going to be slow, and this stored procedure is going to be very slow.
I also had to make some assumptions. Since the IMUPCCD can't be null, then I assume there is a default value of 601040 when the UPC is "blank". Since there was no primary key, I couldn't update through the cursor, but instead had to run a separate update statement, which is also slower. I also had to assume that IMPN uniquely identifies a row of data. I'm not sure if these assumptions are correct, so you may have to modify the sproc to suit your situation.
Also, the original question refers to ItemStatus, but no status column was given in the schema, so I couldn't limit results by it in my tests. However, you can easily add it to the stored procedure's DECLARE blanksCursor CURSOR FOR ... WHERE ... statement in the WHERE clause.
The Test Data (in a database called stackoverflow)
USE [stackoverflow]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
--DROP TABLE [dbo].[Mfg_ITMMAST];
CREATE TABLE [dbo].[Mfg_ITMMAST](
[IMPN] [varchar](30) NOT NULL,
[IMDESC] [varchar](70) NOT NULL,
[IMUPCCD] [varchar](13) NOT NULL
) ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
INSERT [dbo].[Mfg_ITMMAST] ([IMPN], [IMDESC], [IMUPCCD]) VALUES (N'40000-01', N'test', N'601040')
INSERT [dbo].[Mfg_ITMMAST] ([IMPN], [IMDESC], [IMUPCCD]) VALUES (N'41023-01', N'test', N'601040123456')
INSERT [dbo].[Mfg_ITMMAST] ([IMPN], [IMDESC], [IMUPCCD]) VALUES (N'41001-02', N'test', N'601040')
INSERT [dbo].[Mfg_ITMMAST] ([IMPN], [IMDESC], [IMUPCCD]) VALUES (N'51001-01', N'test', N'601040')
INSERT [dbo].[Mfg_ITMMAST] ([IMPN], [IMDESC], [IMUPCCD]) VALUES (N'51001-02', N'test', N'601040')
INSERT [dbo].[Mfg_ITMMAST] ([IMPN], [IMDESC], [IMUPCCD]) VALUES (N'51014-02', N'test', N'601040234567')
INSERT [dbo].[Mfg_ITMMAST] ([IMPN], [IMDESC], [IMUPCCD]) VALUES (N'61001-01', N'test', N'601040')
The Stored Procedure
CREATE PROCEDURE uspScanForBlankUpcs
AS
-- setup variables for bringing in blank row data
DECLARE #IMPN [varchar](30), #IMUPCCD [varchar](13),
#blankUpc [varchar](13), #upcPrefix [varchar](6),
#random [varchar](6), #retryRandom bit;
SET #blankUpc = '601040'; -- This is the value of IMUPCCD when it is "blank"
SET #upcPrefix = '601040'; -- This is prefix for our randomly generated UPC
-- setup the cursor, query for items with "blank" UPCs
DECLARE blanksCursor CURSOR FOR
SELECT IMPN
FROM [Mfg_ITMMAST]
WHERE (LEFT(IMPN, 5) >= '40000' AND
LEFT(IMPN, 5) < '60000' AND
RIGHT(IMPN, 2) IN ('01','02')) AND
IMUPCCD = #blankUpc
;
-- open the cursor
OPEN blanksCursor;
-- load the next row from the cursor
FETCH NEXT FROM blanksCursor
INTO #IMPN;
-- loop through each row of the cursor
WHILE ##FETCH_STATUS = 0
BEGIN
--PRINT 'IMPN: ' + #IMPN;
-- try to create a new random number
SET #retryRandom = 1;
WHILE #retryRandom = 1
BEGIN
-- get a random number for the UPC, then left-pad it with zeros to 6 digits
SET #random = RIGHT('00000' + CONVERT(VARCHAR, FLOOR(RAND() * 999999)), 6);
-- concatenate the UPC prefix with the random number
SET #IMUPCCD = #upcPrefix + #random
--PRINT 'IMUPCCD: ' + #IMUPCCD;
-- see if this UPC already exists on another item
IF (SELECT COUNT(*) FROM [Mfg_ITMMAST] WHERE [IMUPCCD] = #IMUPCCD) > 0
SET #retryRandom = 1; -- UPC already existed (collision) try again
ELSE
SET #retryRandom = 0; -- didn't already exist, so exit out of loop
END
--PRINT 'Updating...';
-- Update the UPC with the random number
UPDATE [Mfg_ITMMAST]
SET IMUPCCD = #IMUPCCD
WHERE IMPN = #IMPN
;
-- Load the next result
FETCH NEXT FROM blanksCursor
INTO #IMPN;
END
CLOSE blanksCursor;
DEALLOCATE blanksCursor;
GO
Running the Stored Procedure
exec uspScanForBlankUpcs;
Resources that I used for this procedure:
MSDN - Creating Stored Procedure
MSDN - DECLARE CURSOR (Transact-SQL)

Answer 2

This answer focuses on how to assign UPC codes from your company prefix to new products when there are "gaps" in the sequence or you are reusing UPC codes from inactive product (not recommended).
UPC codes are made up of 3 parts:
The first is the company prefix.
The second is the item reference.
The third is the check digit.
In this example the company prefix is 0601040. The leading zero is beyond the scope of this question.
The item reference is a range of numbers the size of which depends up on the number of digits in the company prefix. In this example we have 6 digits in the company prefix (don't count the leading zero) and 1 digit for the check digit which leaves 5 digits for the item reference. This makes the item reference range 0 through 99999. You need to find numbers in this range that are not used.
The check digit is computed using the other 11 digits of the UPC code:
http://www.gs1.org/how-calculate-check-digit-manually
Unless you need to store invalid UPC codes because you accept bad data from an outside system there are advantages to storing the company prefix and item reference as separate fields in the table and making the UPC an indexed persistent computed field:
-- Function to output UPC code based on Company Prefix and Item Reference:
CREATE FUNCTION [dbo].[calc_UPC]
(#company_prefix varchar(10), #item_reference int)
RETURNS char(12)
WITH SCHEMABINDING
AS
BEGIN
declare
#upc char(12),
#checkdigit int
if SUBSTRING(#company_prefix, 1, 1) = 0
begin
set #upc = substring(#company_prefix, 2, 10) + right('000000000000' + ltrim(str(#item_reference)), 12 - len(#company_prefix))
set #checkdigit = (1000 - (
convert(int, substring(#upc, 1, 1)) * 3 +
convert(int, substring(#upc, 2, 1)) * 1 +
convert(int, substring(#upc, 3, 1)) * 3 +
convert(int, substring(#upc, 4, 1)) * 1 +
convert(int, substring(#upc, 5, 1)) * 3 +
convert(int, substring(#upc, 6, 1)) * 1 +
convert(int, substring(#upc, 7, 1)) * 3 +
convert(int, substring(#upc, 8, 1)) * 1 +
convert(int, substring(#upc, 9, 1)) * 3 +
convert(int, substring(#upc, 10, 1)) * 1 +
convert(int, substring(#upc, 11, 1)) * 3)) % 10
set #upc = rtrim(#upc) + ltrim(str(#checkdigit))
end
return #upc
END
GO
-- Example Table of products:
CREATE TABLE [dbo].[Product](
[product_id] [int] IDENTITY(1,1) NOT NULL,
[company_prefix] [varchar](10) NULL,
[item_reference] [int] NULL,
[upc] AS ([dbo].[calc_UPC]([company_prefix],[item_reference])) PERSISTED,
CONSTRAINT [PK_Product] PRIMARY KEY CLUSTERED
(
[product_id] ASC
))
ALTER TABLE [dbo].[Product] WITH CHECK ADD CONSTRAINT [item_reference_greater_equal_zero] CHECK (([item_reference]>=(0)))
GO
ALTER TABLE [dbo].[Product] CHECK CONSTRAINT [item_reference_greater_equal_zero]
GO
-- Existing records with UPC codes:
insert product (company_prefix, item_reference) values ( '0601040', 3)
insert product (company_prefix, item_reference) values ( '0601040', 5)
-- Example of 4 new products without UPC codes
insert product DEFAULT VALUES
insert product DEFAULT VALUES
insert product DEFAULT VALUES
insert product DEFAULT VALUES
GO
-- Next we need a table of all possible item references.
-- This is the best implementation I have found for generating numbers:
--Creates a table of sequential numbers, useful for all sorts of things
--Created 08/26/05 by Oskar Austegard from article at
--http://msdn.microsoft.com/library/en-us/dnsqlpro03/html/sp03k1.asp
--Limits: #Min and #Max must be between -2147483647 and 2147483647, including.
--If #Max <= #Min, only a single record with #Min is created
CREATE FUNCTION [dbo].[NumberTable] (#Min int, #Max int)
RETURNS #T TABLE (Number int NOT NULL PRIMARY KEY)
AS
BEGIN
-- Seed the table with the min value
INSERT #T VALUES (#Min)
--Loop until all the rows are created, inserting ever more records for each iteration (1, 2, 4, etc)
WHILE ##ROWCOUNT > 0
BEGIN
INSERT #T
--Get the next values by adding the current max - start value + 1 to each existing number
--need to calculate increment value first to avoid arithmetic overflow near limits of int
SELECT t.Number + (x.MaxNumber - #Min + 1)
FROM #T t
CROSS JOIN (SELECT MaxNumber = MAX(Number) FROM #T) x --Current max
WHERE
--Do not exceed the Max - shift the increment to the right side to take advantage of index
t.Number <= #Max - (x.MaxNumber - #Min + 1)
END
RETURN
END
GO
-- For 10,000 numbers the performance of this function is good,
-- but when the range is known I prefer the performance I get with a static table:
-- Create a table of numbers between 0 and 99999
CREATE table Numbers (number int)
insert Numbers (number)
select n.Number
from dbo.NumberTable(0, 99999) n
-- Now we can easily assign UPC codes using the available item reference values in your Company Prefix in a single update:
declare #company_prefix varchar(10)
set #company_prefix = '0601040' -- The function requires the leading zero
update
p
set
item_reference = n.number,
company_prefix = #company_prefix
from
(
select
p.product_id,
ROW_NUMBER() OVER (order by product_id) [row]
from
dbo.product p
where
p.company_prefix is null
) u
inner join dbo.product p on p.product_id = u.product_id
inner join
(
select
s.Number,
ROW_NUMBER() over (order by s.Number) [row]
from
(
select n.Number from
(
select
n.Number
from
dbo.Numbers n --Table(#sequence, #size - 1) n
left outer join dbo.Product p
on p.company_prefix = #company_prefix
and n.Number = p.item_reference
where
p.product_id is null
) n
) s
) n on n.[row] = u.[row]
GO
select * from product
Using this approach you don't need to worry about invalid check digits and you can easily assign UPC codes to new products from your GS1 assigned UCC block. It also makes it easy to start assigning UPC codes from a new company prefix. You can support EAN13 codes the same way with a small change to the function:
CREATE FUNCTION [dbo].[calc_EAN13]
(#company_prefix varchar(10), #item_reference int)
RETURNS char(13)
WITH SCHEMABINDING
AS
BEGIN
declare
#ean13 char(13),
#checkdigit int
set #ean13 = #company_prefix
set #ean13 = #company_prefix + right('0000000000000' + ltrim(str(#item_reference)), 12 - len(#company_prefix))
set #checkdigit = (1000 - (
convert(int, substring(#ean13, 1, 1)) * 1 +
convert(int, substring(#ean13, 2, 1)) * 3 +
convert(int, substring(#ean13, 3, 1)) * 1 +
convert(int, substring(#ean13, 4, 1)) * 3 +
convert(int, substring(#ean13, 5, 1)) * 1 +
convert(int, substring(#ean13, 6, 1)) * 3 +
convert(int, substring(#ean13, 7, 1)) * 1 +
convert(int, substring(#ean13, 8, 1)) * 3 +
convert(int, substring(#ean13, 9, 1)) * 1 +
convert(int, substring(#ean13, 10, 1)) * 3 +
convert(int, substring(#ean13, 11, 1)) * 1 +
convert(int, substring(#ean13, 12, 1)) * 3)) % 10
set #ean13 = rtrim(#ean13) + ltrim(str(#checkdigit))
return #ean13
END
GO