Question: My webapplication has a table in the database with an `id` column which will always be unique for each row. In addition to this I want to have another column called `code` that will have a 6 digit unique Alphanumeric code with numbers 0-9 and alphabets A-Z. Alphabets and number can be duplicate in a code. i.e. `FFQ77J`. I understand the uniqueness of this 6 digit alphanumeric code reduces over time as more rows are added but for now I am ok with this. 

**Requirement (update)**
 - The code should be at least of length 6 
 - Each code should be Alphanumeric 

So I want to generate this Alphanumeric code. 

**Question**

What is a good way to do this? 

* Should I generate the code and after the generation, run a query to the database and check if it already exists, and if so then generate a new one? To ensure the uniqueness, does this piece of code need to be synchronized so that only one thread runs it?
* Is there something built-in to the database that will let me do this?

For the generation I will be using something like this which I saw in [this answer](https://stackoverflow.com/a/41156/44286)

```
char[] symbols = new char[36];
char[] buf;
    for (int idx = 0; idx < 10; ++idx)
        symbols[idx] = (char) ('0' + idx);
    for (int idx = 10; idx < 36; ++idx)
        symbols[idx] = (char) ('A' + idx - 10);
public String nextString()
{
    for (int idx = 0; idx < buf.length; ++idx)
        buf[idx] = symbols[random.nextInt(symbols.length)];
    return new String(buf);
}

```

Answer: 
Since it's a requirement for the shortcode to *not* be guessable, you don't want to tie it to your uniqueID row ID. Otherwise that means your rowID needs to be random, in addition to unique. Starting with a counter 0, and incrementing, makes it pretty obvious when your codes are: 000001, 000002, 000003, and so forth.

For your short code, generate a random 32bit int, omit the sign and convert to base36. Make a call to your database, to ensure it's available. 

You haven't explicitly called out scalability, but I think it's important to understand the limitations of your design wrt to scale.

At 2^31 possible 6 char base36 values, you will have collisions at ~65k rows (see [Birthday Paradox questions](https://stackoverflow.com/search?q=birthday%20paradox))

From your comment, modify your code:

```
public String nextString()
{
    return Integer.toString(random.nextInt(),36);
}

```
Simply, you can use `Integer.toString(int i, int radix)`. Since you have base 36(26 letters+10 digits) you set the radix to 36 and `i` to your integer. For example, to use `16501`, do:

```
 String identifier=Integer.toString(16501, 36);

```

You can uppercase it with `.toUpperCase()`

Now onto your other questions, yes, you should query the database first to ensure it doesn't exist. If depending on the database, it may need to be synchronized, or it may not be as it'll use its own locking system. In any case, you'd need to tell us *which* database.

On the question of whether there's a builtin, we'd need to know the DB type as well.