A good algorithm for generating an order number

Question

As much as I like using GUIDs as the unique identifiers in my system, it is not very user-friendly for fields like an order number where a customer may have to repeat that to a

Answer 1

Maybe you could try generating some unique text using a markov chain - see here for an example implementation in Python. Maybe use sequential numbers (rather than random ones) to generate the chain, so that (hopefully) the each order number is unique.

Just a warning, though - see here for what can possibly happen if you aren't careful with your settings.

Answer 2

If the middle tier cannot check what "order numbers" already exists in the database, the best it can do will be the equivalent of generating a random number. However, if you generate a random number that's constrained to be less than 1 billion, you should start worrying about accidental collisions at around sqrt(1 billion), i.e., after a few tens of thousand entries generated this way, the risk of collisions is material. What if the order number is sequential but in a disguised way, i.e. the next multiple of some large prime number modulo 1 billion -- would that meet your requirements?

Answer 3

We do TTT-CCCCCC-1A-N1.

• T = Circuit type (D1E=DS1 EEL, D1U=DS1 UNE, etc.)
• C = 6 Digit Customer ID
• 1 = The customer's first location
• A = The first circuit (A=1, B=2, etc) at this location
• N = Order type (N=New, X=Disconnect, etc)
• 1 = The first order of this kind for this circuit

Answer 4

Your 10 digit requirement is a huge limitation. Consider a two stage approach.

1. Use a GUID
2. Prefix the GUID with a 10 digit (or 5 or 4 digit) hash of the GUID.

You will have multiple hits on the hash value. But not that many. The customer service people will very easily be able to figure out which order is in question based on additional information from the customer.

Answer 5

The straightforward answer to most of your bullet points:

Make the first six digits a sequentially-increasing field, and append three digits of hash to the end. Or seven and two, or eight and one, depending on how many orders you envision having to support.

However, you'll still have to call a function on the back-end to reserve a new order number; otherwise, it's impossible to guarantee a non-collision, since there are so few digits.

Answer 6

Use primitive polynomials as finite field generator.