ChatGPT解决这个技术问题 Extra ChatGPT

Generating a UUID in Postgres for Insert statement?

My question is rather simple. I'm aware of the concept of a UUID and I want to generate one to refer to each 'item' from a 'store' in my DB with. Seems reasonable right?

The problem is the following line returns an error:

honeydb=# insert into items values(
uuid_generate_v4(), 54.321, 31, 'desc 1', 31.94);
ERROR:  function uuid_generate_v4() does not exist
LINE 2: uuid_generate_v4(), 54.321, 31, 'desc 1', 31.94);
        ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.

I've read the page at: http://www.postgresql.org/docs/current/static/uuid-ossp.html

https://i.stack.imgur.com/BDeZ3.png

I'm running Postgres 8.4 on Ubuntu 10.04 x64.

Postgres natively supports UUID as a data type, even capable of being indexed and used as primary key. But to generate a UUID value, such as to establish a default value for a column, you need a Postgres extension (a plugin). Many builds (distributions) of Postgres include such an extension but do not activate the extension. See the correct answer by Craig Ringer to learn how to activate it.
If you have uuid-ossp installed & you still get this error try prefixing the function with your schema name, e.g. select dbo.uuid_generate_v4()

C
Craig Ringer

uuid-ossp is a contrib module, so it isn't loaded into the server by default. You must load it into your database to use it.

For modern PostgreSQL versions (9.1 and newer) that's easy:

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

but for 9.0 and below you must instead run the SQL script to load the extension. See the documentation for contrib modules in 8.4.

For Pg 9.1 and newer instead read the current contrib docs and CREATE EXTENSION. These features do not exist in 9.0 or older versions, like your 8.4.

If you're using a packaged version of PostgreSQL you might need to install a separate package containing the contrib modules and extensions. Search your package manager database for 'postgres' and 'contrib'.


@advocate You're using a distro-packaged PostgreSQL so you should be able to just apt-get install postgresql-contrib or similar. Try apt-cache search postgresql |grep contrib to find the package name you want.
sudo apt-get install postgresql-contrib has successfully run. Then I had to run psql -d dbname -f SHAREDIR/contrib/module.sql and now it works!!! select uuid_generate_v1(); returns 1 now now. Thanks so much!
Note that if you don't install the postgresql-contrib package, you'll get the error: ERROR: could not open extension control file "/usr/share/postgresql/9.3/extension/uuid-ossp.control": No such file or directory
I posted that comment as the error string struck out on Google. Also it gives a specific package name, for Ubuntu at least.
If you imported a db that has the uuid-ossp in the Extensions already, uuid_generate_v4() might not work. If that's the case, just remove the extension, and create it again and it should work.
Z
ZuzEL

Without extensions (cheat)

If you need a valid v4 UUID

SELECT uuid_in(overlay(overlay(md5(random()::text || ':' || random()::text) placing '4' from 13) placing to_hex(floor(random()*(11-8+1) + 8)::int)::text from 17)::cstring);

https://i.stack.imgur.com/OA6Qk.png

Thanks to @Denis Stafichuk @Karsten and @autronix

Or you can simply get UUID-like value by doing this (if you don't care about the validity):

SELECT uuid_in(md5(random()::text || random()::text)::cstring);

output>> c2d29867-3d0b-d497-9191-18a9d8ee7830

(works at least in 8.4)


To follow up your PS: SELECT uuid_in(md5(random()::text || now()::text)::cstring);
@MattDiPasquale Probably not in any sense "better" than using uuid-ossp, but I'm for instance working on a PostgreSQL instance where I don't have the sufficient privileges to install an extension.
@JosephLennox: clock_timestamp() is the better alternative in either case for this. Unlike now() or CURRENT_TIMESTAMP it is volatile and returns the actual current time. SELECT uuid_in(md5(random()::text || clock_timestamp()::text)::cstring); Also, in modern Postgres, you can simply cast: SELECT md5(random()::text || clock_timestamp()::text)::uuid - no need for more magic. Use-case: stackoverflow.com/a/8335376/939860
Nope. If this does work at all its sheer luck. a UUID has a format, its not just random hex chars thrown together.The first number of 3rd group is the uuid version for intance (usually 4 these days). If your application checks that digit to see what version of uuid its dealing with, and do something accordingly, it will fail in your code.
@Tuncay Göncüoğlu: It's fairly straightforward to generate a valid v4 UUID (the string overlay approach wastes 2 bits of randomness though): select overlay(overlay(md5(random()::text || ':' || clock_timestamp()::text) placing '4' from 13) placing '8' from 17)::uuid;
L
Lukasz Szozda

PostgreSQL 13 supports natively gen_random_uuid ():

PostgreSQL includes one function to generate a UUID: gen_random_uuid () → uuid This function returns a version 4 (random) UUID. This is the most commonly used type of UUID and is appropriate for most applications.

db<>fiddle demo


I don't undertstand why there are so much other (non working) answer, it's as simple as this! should be the accepted answer
@pdem because PostgreSQL 13 is rather new. For instance, I am still working on server version 10. This seems the best alternative for version 13, though.
@borellini I understand, I actually have a production server in 12, I had to create this patch function to make it work create function gen_random_uuid() RETURNS uuid as $$ SELECT md5(random()::text || clock_timestamp()::text)::uuid $$ LANGUAGE SQL;
I like this polyfill, easy to upgrade with.
B
Basil Bourque

The answer by Craig Ringer is correct. Here's a little more info for Postgres 9.1 and later…

Is Extension Available?

You can only install an extension if it has already been built for your Postgres installation (your cluster in Postgres lingo). For example, I found the uuid-ossp extension included as part of the installer for Mac OS X kindly provided by EnterpriseDB.com. Any of a few dozen extensions may be available.

To see if the uuid-ossp extension is available in your Postgres cluster, run this SQL to query the pg_available_extensions system catalog:

SELECT * FROM pg_available_extensions;

Install Extension

To install that UUID-related extension, use the CREATE EXTENSION command as seen in this this SQL:

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

Beware: I found the QUOTATION MARK characters around extension name to be required, despite documentation to the contrary.

The SQL standards committee or Postgres team chose an odd name for that command. To my mind, they should have chosen something like "INSTALL EXTENSION" or "USE EXTENSION".

Verify Installation

You can verify the extension was successfully installed in the desired database by running this SQL to query the pg_extension system catalog:

SELECT * FROM pg_extension;

UUID as default value

For more info, see the Question: Default value for UUID column in Postgres

The Old Way

The information above uses the new Extensions feature added to Postgres 9.1. In previous versions, we had to find and run a script in a .sql file. The Extensions feature was added to make installation easier, trading a bit more work for the creator of an extension for less work on the part of the user/consumer of the extension. See my blog post for more discussion.

Types of UUIDs

By the way, the code in the Question calls the function uuid_generate_v4(). This generates a type known as Version 4 where nearly all of the 128 bits are randomly generated. While this is fine for limited use on smaller set of rows, if you want to virtually eliminate any possibility of collision, use another "version" of UUID.

For example, the original Version 1 combines the MAC address of the host computer with the current date-time and an arbitrary number, the chance of collisions is practically nil.

For more discussion, see my Answer on related Question.


And you can also use CREATE EXTENSION IF NOT EXISTS ... if you are not sure and don't want to check (in a script e.g.)
Version 4 UUIDs are fine for nearly any size data set, not only "limited use on smaller sets of rows." You would have to generate 1 billion UUIDs per second for about 85 years (or about 45 million terabytes of data, thousands of times larger than the biggest databases today) to even have a 50% chance of collision. Unless you're the NSA, Version 4 is fine for about any purpose. Version 1, on the other hand, suffered from the fact that MAC addresses are sequentially-assigned (and are often spoofed or unavailable), which is part of why later versions were introduced.
@BasilBourque The issue with v1 isn't the probability of collision when correctly implemented, it's the probability of incorrect implementation. As Wikipedia puts it: "The uniqueness of version 1 and 2 UUIDs ... also depends on network card manufacturers properly assigning unique MAC addresses to their cards, which like other manufacturing processes is subject to error." Also, in some containerized or virtualized environments, true MAC addresses from the underlying hardware are not available. If many containers have the same MAC but their own clockseq counters, their v1 UUIDs may collide.
@BasilBourque Weaknesses in v1 are not the main point of my comment, though. Your original answer implies that v4 is not suitable for large datasets due to a higher probability of collision than v1. This is misleading and possibly false, though it is hard to calculate the collision probability for v1 because it is so implementation-dependent.
@BasilBourque For example, the node-uuid project calculates the probability of their clockseq counters being the same (so that two processes would generate the same sequence of v1 UUIDs) as 1 in 4.6e18. This is tiny, yes, but much more likely than the chance of immediate collision in v4, which is 1 in 5.3e36. Obviously the longer you generate v4 UUIDs the more likely a collision becomes, which is not true of v1, but you'd have to generate 1.52 billion v4 UUIDs before the probability of collision exceeded that of node's v1 implementation. Most people don't have 1.52 billion records per table.
B
Basil Bourque

pgcrypto Extension

As of Postgres 9.4, the pgcrypto module includes the gen_random_uuid() function. This function generates one of the random-number based Version 4 type of UUID.

Get contrib modules, if not already available.

sudo apt-get install postgresql-contrib-9.4

Use pgcrypto module.

CREATE EXTENSION "pgcrypto";

The gen_random_uuid() function should now available;

Example usage.

INSERT INTO items VALUES( gen_random_uuid(), 54.321, 31, 'desc 1', 31.94 ) ;


Quote from Postgres doc on uuid-ossp module.

Note: If you only need randomly-generated (version 4) UUIDs, consider using the gen_random_uuid() function from the pgcrypto module instead.


Yes, but see also blog.starkandwayne.com/2015/05/23/… where they warn about fragmentation and suggest uuid-ossp instead.
Actually, see postgresql.org/message-id/… where the uuid fragmentation issue in Postgres is debunked
But postgres does have clustered indexes in the latest version, making the post linked in the above comment inconclusive and incorrect and we are right back to square 1.
@MichaelGoldshteyn: no, Postgres does not have clustered indexes (as of Postgres 12)
The article in the first comment has moved here. TLDR, though, the second link about debunking the "fragmentation" issue found the article that started the myth, and it is based on databases with clustered indexes, which as @a_horse_with_no_name has said, postgres does not have. It has a function to do a one-time reordering of data so the keys are clustered, but it is not the same as SQL Server. SQL Server can store rows ordered by a key, and shuffles things around as new records are added to keep the keys in order.
l
labulaka

Update from 2021, There is no need for a fancy trick to auto generate uuid on insert statement.

Just do one thing:

Set default value of DEFAULT gen_random_uuid () to your uuid column. That is all.

Say, you have a table like this:

CREATE TABLE table_name (
    unique_id UUID DEFAULT gen_random_uuid (),
    first_name VARCHAR NOT NULL,
    last_name VARCHAR NOT NULL,
    email VARCHAR NOT NULL,
    phone VARCHAR,
    PRIMARY KEY (unique_id)
);

Now you need NOT to do anything to auto insert uuid values to unique_id column. Because you already defined a default value for it. You can simply focus on inserting onto other columns, and postgresql takes care of your unique_id. Here is a sample insert statement:

INSERT INTO table_name (first_name, last_name, email, phone) 
VALUES (
    'Beki',
    'Otaev',
    'beki@bekhruz.com',
    '123-456-123'
)

Notice there is no inserting into unique_id as it is already taken care of.

About other extensions like uuid-ossp, you can bring them on if you are not satisfied with postgres's standard gen_random_uuid () function. Most of the time, you should be fine without them on


As Lukasz Szozda noted in stackoverflow.com/a/61970869/13950739, gen_random_uuid() is available in core PostgreSQL (so don't need to install any extension) as of PostgreSQL 13.
At the bottom of this article: starkandwayne.com/blog/uuid-primary-keys-in-postgresql there is a discussion on a possible con of gen_random_uuid(). Any comment as to the validity of the statement?
if you mean negative side effect with respect to keyspace fragmentation, then: No, that is not an issue: postgresql.org/message-id/… – as mentioned in a comment on brillout's answer
P
Paolo Fernandes
ALTER TABLE table_name ALTER COLUMN id SET DEFAULT uuid_in((md5((random())::text))::cstring);

After reading @ZuzEL's answer, i used the above code as the default value of the column id and it's working fine.


S
Satish Mali

The uuid-ossp module provides functions to generate universally unique identifiers (UUIDs)

uuid_generate_v1() This function generates a version 1 UUID.

Add Extension

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

Verify Extension

SELECT * FROM pg_extension;

Run Query

INSERT INTO table_name(id, column1, column2 , column3, ...) VALUES (uuid_generate_v1(), value1, value2, value3...);

Verify table data


k
keemsisi

Try this out:

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";  
SELECT uuid_generate_v1();

You can call uuid_generate_v1() to generate random UUID after you have activated it with


s
skyho
SELECT uuid_generate_v5(uuid_ns_url (), 'test');