Làm cách nào để bạn tạo một chuỗi ngẫu nhiên phù hợp với ID phiên trong PostgreSQL?

Tôi muốn tạo một chuỗi ngẫu nhiên để sử dụng trong xác minh phiên bằng PostgreSQL. Tôi biết tôi có thể nhận được một số ngẫu nhiên SELECT random(), vì vậy tôi đã thử SELECT md5(random()), nhưng điều đó không hiệu quả. Tôi có thể làm cái này như thế nào?

Tôi muốn đề xuất giải pháp đơn giản này:

Đây là một hàm khá đơn giản trả về một chuỗi ngẫu nhiên có độ dài đã cho:

Create or replace function random_string(length integer) returns text as
$$
declare
  chars text[] := '{0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}';
  result text := '';
  i integer := 0;
begin
  if length < 0 then
    raise exception 'Given length cannot be less than 0';
  end if;
  for i in 1..length loop
    result := result || chars[1+random()*(array_length(chars, 1)-1)];
  end loop;
  return result;
end;
$$ language plpgsql;

Và cách sử dụng:

select random_string(15);

Ví dụ đầu ra:

select random_string(15) from generate_series(1,15);

  random_string
-----------------
 5emZKMYUB9C2vT6
 3i4JfnKraWduR0J
 R5xEfIZEllNynJR
 tMAxfql0iMWMIxM
 aPSYd7pDLcyibl2
 3fPDd54P5llb84Z
 VeywDb53oQfn9GZ
 BJGaXtfaIkN4NV8
 w1mvxzX33NTiBby
 knI1Opt4QDonHCJ
 P9KC5IBcLE0owBQ
 vvEEwc4qfV4VJLg
 ckpwwuG8YbMYQJi
 rFf6TchXTO3XsLs
 axdQvaLBitm6SDP
(15 rows)

Bạn có thể khắc phục nỗ lực ban đầu của mình như sau:

SELECT md5(random()::text);

Đơn giản hơn nhiều so với một số gợi ý khác. :-)

Dựa trên giải pháp của Marcin, bạn có thể làm điều này để sử dụng một bảng chữ cái tùy ý (trong trường hợp này là tất cả 62 ký tự chữ và số ASCII):

SELECT array_to_string(array 
       ( 
              select substr('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', trunc(random() * 62)::integer + 1, 1)
              FROM   generate_series(1, 12)), '');

Bạn có thể nhận 128 bit ngẫu nhiên từ UUID. Đây là phương pháp để hoàn thành công việc trong PostgreSQL hiện đại.

CREATE EXTENSION pgcrypto;
SELECT gen_random_uuid();

           gen_random_uuid            
--------------------------------------
 202ed325-b8b1-477f-8494-02475973a28f

Cũng có thể đáng đọc các tài liệu về UUID

Loại dữ liệu uuid lưu trữ Số nhận dạng duy nhất phổ biến (UUID) theo định nghĩa của RFC 4122, ISO / IEC 9834-8: 2005 và các tiêu chuẩn liên quan. (Một số hệ thống gọi kiểu dữ liệu này là số nhận dạng duy nhất trên toàn cầu, hoặc GUID, thay vào đó.) Số nhận dạng này là một số lượng 128 bit được tạo bởi một thuật toán được chọn để làm cho rất ít khả năng rằng cùng một số nhận dạng sẽ được tạo bởi bất kỳ ai khác trong vũ trụ đã biết bằng cách sử dụng cùng một thuật toán. Do đó, đối với các hệ thống phân tán, các mã định danh này cung cấp sự đảm bảo về tính duy nhất tốt hơn so với các trình tạo chuỗi, chỉ là duy nhất trong một cơ sở dữ liệu duy nhất.

Mức độ hiếm khi xảy ra va chạm với UUID hay có thể đoán được? Giả sử chúng là ngẫu nhiên,

Khoảng 100 nghìn tỷ UUID phiên bản 4 sẽ cần được tạo để có 1 trong một tỷ cơ hội xảy ra một bản sao duy nhất ("va chạm"). Cơ hội xảy ra một vụ va chạm chỉ tăng lên 50% sau khi 261 UUID (2,3 x 10 ^ 18 hoặc 2,3 tạ) được tạo ra. Liên hệ những con số này với cơ sở dữ liệu và xem xét vấn đề liệu xác suất xảy ra xung đột UUID Phiên bản 4 là không đáng kể hay không, hãy xem xét một tệp chứa 2,3 nghìn tỷ UUID Phiên bản 4, với 50% khả năng chứa một xung đột UUID. Nó sẽ có kích thước 36 exabyte, giả sử không có dữ liệu hoặc chi phí nào khác, lớn hơn hàng nghìn lần so với cơ sở dữ liệu lớn nhất hiện đang tồn tại, có thứ tự là petabyte. Với tốc độ 1 tỷ UUID được tạo mỗi giây, sẽ mất 73 năm để tạo UUID cho tệp. Nó cũng sẽ yêu cầu khoảng 3. 6 triệu ổ cứng 10 terabyte hoặc hộp băng để lưu trữ nó, giả sử không có bản sao lưu hoặc dự phòng. Việc đọc tệp ở tốc độ truyền "disk-to-buffer" điển hình là 1 gigabit mỗi giây sẽ cần hơn 3000 năm đối với một bộ xử lý. Vì tỷ lệ lỗi đọc không thể khôi phục của ổ đĩa tốt nhất là 1 bit trên 1018 bit đọc, trong khi tệp sẽ chứa khoảng 1020 bit, chỉ cần đọc tệp một lần từ đầu đến cuối sẽ dẫn đến kết quả sai nhiều hơn khoảng 100 lần đọc UUID hơn các bản sao. Các lỗi lưu trữ, mạng, nguồn và các lỗi phần cứng và phần mềm khác chắc chắn sẽ thường xuyên hơn hàng nghìn lần so với các sự cố trùng lặp UUID. tốc độ truyền 1 gigabit mỗi giây sẽ cần hơn 3000 năm đối với một bộ xử lý. Vì tỷ lệ lỗi đọc không thể khôi phục của ổ đĩa tốt nhất là 1 bit trên 1018 bit đọc, trong khi tệp sẽ chứa khoảng 1020 bit, chỉ cần đọc tệp một lần từ đầu đến cuối sẽ dẫn đến kết quả sai nhiều hơn khoảng 100 lần đọc UUID hơn các bản sao. Các lỗi lưu trữ, mạng, nguồn và các lỗi phần cứng và phần mềm khác chắc chắn sẽ thường xuyên hơn hàng nghìn lần so với các sự cố trùng lặp UUID. tốc độ truyền 1 gigabit mỗi giây sẽ cần hơn 3000 năm đối với một bộ xử lý. Vì tỷ lệ lỗi đọc không thể khôi phục của ổ đĩa tốt nhất là 1 bit trên 1018 bit đọc, trong khi tệp sẽ chứa khoảng 1020 bit, chỉ cần đọc tệp một lần từ đầu đến cuối sẽ dẫn đến kết quả sai nhiều hơn khoảng 100 lần đọc UUID hơn các bản sao. Các lỗi lưu trữ, mạng, nguồn và các lỗi phần cứng và phần mềm khác chắc chắn sẽ thường xuyên hơn hàng nghìn lần so với các sự cố trùng lặp UUID.

nguồn: wikipedia

Tóm tắt,

• UUID được chuẩn hóa.
• gen_random_uuid()là 128 bit ngẫu nhiên được lưu trữ trong 128 bit (2 ** 128 kết hợp). 0-lãng phí.
• random() chỉ tạo 52 bit ngẫu nhiên trong PostgreSQL (2 ** 52 kết hợp).
• md5()được lưu trữ dưới dạng UUID là 128 bit, nhưng nó chỉ có thể ngẫu nhiên như đầu vào của nó ( 52 bit nếu sử dụngrandom() )
• md5()được lưu trữ dưới dạng văn bản là 288 bit, nhưng nó chỉ có thể ngẫu nhiên như đầu vào của nó ( 52 bit nếu sử dụngrandom() ) - gấp đôi kích thước của UUID và một phần của độ ngẫu nhiên)
• md5() như một hàm băm, có thể được tối ưu hóa đến mức nó không hoạt động hiệu quả.
• UUID có hiệu quả cao để lưu trữ: PostgreSQL cung cấp một loại chính xác là 128 bit. Không giống như textvà varchar, vv lưu trữ dưới dạng một varlenacó chi phí cho độ dài của chuỗi.
• PostgreSQL UUID tiện lợi đi kèm với một số toán tử, cấu trúc và tính năng mặc định.

Tôi đã chơi với PostgreSQL gần đây và tôi nghĩ rằng tôi đã tìm thấy một giải pháp tốt hơn một chút, chỉ sử dụng các phương thức PostgreSQL được tích hợp sẵn - không pl / pgsql. Hạn chế duy nhất là nó hiện chỉ tạo chuỗi UPCASE, hoặc số hoặc chuỗi chữ thường.

template1=> SELECT array_to_string(ARRAY(SELECT chr((65 + round(random() * 25)) :: integer) FROM generate_series(1,12)), '');
 array_to_string
-----------------
 TFBEGODDVTDM

template1=> SELECT array_to_string(ARRAY(SELECT chr((48 + round(random() * 9)) :: integer) FROM generate_series(1,12)), '');
 array_to_string
-----------------
 868778103681

Đối số thứ hai của generate_seriesphương thức chỉ ra độ dài của chuỗi.

Hãy sử dụng string_agg!

SELECT string_agg (substr('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', ceil (random() * 62)::integer, 1), '')
FROM   generate_series(1, 45);

Tôi cũng đang sử dụng cái này với MD5 để tạo UUID. Tôi chỉ muốn một giá trị ngẫu nhiên có nhiều bit hơn một random ()số nguyên.

Mặc dù không hoạt động theo mặc định, bạn có thể kích hoạt một trong các tiện ích mở rộng cốt lõi:

CREATE EXTENSION IF NOT EXISTS pgcrypto;

Sau đó, câu lệnh của bạn trở thành một lệnh gọi đơn giản tới gen_salt () tạo ra một chuỗi ngẫu nhiên:

select gen_salt('md5') from generate_series(1,4);

 gen_salt
-----------
$1$M.QRlF4U
$1$cv7bNJDM
$1$av34779p
$1$ZQkrCXHD

Số đứng đầu là số nhận dạng băm. Một số thuật toán có sẵn, mỗi thuật toán có số nhận dạng riêng:

• md5: $ 1 $
• bf: $ 2a $ 06 $
• des: không có định danh
• xdes: _J9 ..

Thông tin thêm về tiện ích mở rộng:

• pgCrypto: http://www.postgresql.org/docs/9.2/static/pgcrypto.html
• Các tiện ích mở rộng được bao gồm: http://www.postgresql.org/docs/9.2/static/contrib.html

BIÊN TẬP

Như được chỉ ra bởi Evan Carrol, kể từ v9.4, bạn có thể sử dụng gen_random_uuid()

http://www.postgresql.org/docs/9.4/static/pgcrypto.html

Tôi không nghĩ rằng bạn đang tìm kiếm một chuỗi ngẫu nhiên. Những gì bạn cần để xác minh phiên là một chuỗi được đảm bảo là duy nhất. Bạn có lưu trữ thông tin xác minh phiên để kiểm tra không? Trong trường hợp đó, bạn cần chuỗi là duy nhất giữa các phiên. Tôi biết hai cách tiếp cận khá đơn giản:

1. Sử dụng một trình tự. Tốt để sử dụng trên một cơ sở dữ liệu duy nhất.
2. Sử dụng UUID. Rất độc đáo, rất tốt trên môi trường phân tán.

UUID được đảm bảo là duy nhất nhờ thuật toán của chúng để tạo; hiệu quả là rất khó xảy ra trường hợp bạn tạo ra hai số giống hệt nhau trên bất kỳ máy nào, bất kỳ lúc nào, (lưu ý rằng điều này mạnh hơn nhiều so với các chuỗi ngẫu nhiên, có chu kỳ nhỏ hơn nhiều so với UUID).

Bạn cần tải phần mở rộng uuid-ossp để sử dụng UUID. Sau khi cài đặt, hãy gọi bất kỳ hàm uuid_generate_vXXX () khả dụng nào trong các lệnh gọi SELECT, INSERT hoặc UPDATE của bạn. Kiểu uuid là một chữ số 16 byte, nhưng nó cũng có một biểu diễn chuỗi.

Tham số INTEGER xác định độ dài của chuỗi. Đảm bảo bao gồm tất cả 62 ký tự alphanum với xác suất như nhau (không giống như một số giải pháp khác trôi nổi trên Internet).

CREATE OR REPLACE FUNCTION random_string(INTEGER)
RETURNS TEXT AS
$BODY$
SELECT array_to_string(
    ARRAY (
        SELECT substring(
            '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
            FROM (ceil(random()*62))::int FOR 1
        )
        FROM generate_series(1, $1)
    ), 
    ''
)
$BODY$
LANGUAGE sql VOLATILE;

@Kavius ​​khuyến nghị sử dụng pgcrypto, nhưng thay vì gen_salt, thì gen_random_bytessao? Và làm thế nào về sha512thay vì md5?

create extension if not exists pgcrypto;
select digest(gen_random_bytes(1024), 'sha512');

Tài liệu:

F.25.5. Hàm dữ liệu ngẫu nhiên

gen_random_bytes (đếm số nguyên) trả về bytea

Trả về số byte ngẫu nhiên mạnh về mặt mật mã. Có thể trích xuất tối đa 1024 byte tại một thời điểm. Điều này là để tránh làm cạn kiệt nhóm tạo ngẫu nhiên.

select * from md5(to_char(random(), '0.9999999999999999'));

select encode(decode(md5(random()::text), 'hex')||decode(md5(random()::text), 'hex'), 'base64')