คุณสร้างสตริงแบบสุ่มที่เหมาะสมกับรหัสเซสชันใน PostgreSQL ได้อย่างไร

ฉันต้องการสร้างสตริงแบบสุ่มเพื่อใช้ในการตรวจสอบเซสชันโดยใช้ PostgreSQL ฉันรู้ว่าฉันสามารถสุ่มเลขได้SELECT random()ฉันจึงลองSELECT md5(random())แต่ก็ไม่ได้ผล ฉันจะทำเช่นนี้ได้อย่างไร?

ฉันขอแนะนำวิธีง่ายๆนี้:

นี่เป็นฟังก์ชั่นที่ค่อนข้างเรียบง่ายที่ส่งกลับสตริงสุ่มตามความยาวที่กำหนด:

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;

และการใช้งาน:

select random_string(15);

ตัวอย่างผลลัพธ์:

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)

คุณสามารถแก้ไขความพยายามครั้งแรกของคุณได้ดังนี้:

SELECT md5(random()::text);

ง่ายกว่าคำแนะนำอื่น ๆ มาก :-)

จากโซลูชันของ Marcin คุณสามารถทำได้โดยใช้ตัวอักษรตามอำเภอใจ (ในกรณีนี้คืออักขระตัวเลขและตัวอักษร ASCII ทั้งหมด 62 ตัว):

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

คุณสามารถสุ่มได้ 128 บิตจาก UUID นี่คือวิธีการทำงานให้เสร็จใน PostgreSQL สมัยใหม่

CREATE EXTENSION pgcrypto;
SELECT gen_random_uuid();

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

อาจคุ้มค่ากับการอ่านเอกสารใน UUID ด้วย

ประเภทข้อมูล uuid จะจัดเก็บ Universally Unique Identifiers (UUID) ตามที่กำหนดโดยRFC 4122, ISO / IEC 9834-8: 2005และมาตรฐานที่เกี่ยวข้อง (ระบบบางระบบอ้างถึงชนิดข้อมูลนี้ว่าเป็นตัวระบุที่ไม่ซ้ำกันทั่วโลกหรือ GUID แทน) ตัวระบุนี้เป็นปริมาณ 128 บิตที่สร้างขึ้นโดยอัลกอริทึมที่เลือกเพื่อให้เป็นไปได้ยากมากที่บุคคลอื่นจะสร้างตัวระบุเดียวกัน ในจักรวาลที่รู้จักโดยใช้อัลกอริทึมเดียวกัน ดังนั้นสำหรับระบบแบบกระจายตัวระบุเหล่านี้จึงให้การรับประกันความเป็นเอกลักษณ์ที่ดีกว่าตัวสร้างลำดับซึ่งจะไม่ซ้ำกันภายในฐานข้อมูลเดียวเท่านั้น

การชนกับ UUID เกิดน้อยเพียงใดหรือเดาได้? สมมติว่าเป็นแบบสุ่ม

จะต้องมีการสร้าง UUID เวอร์ชัน 4 ประมาณ 100 ล้านล้านเพื่อให้มีโอกาส 1 ในพันล้านที่จะเกิดรายการซ้ำกัน ("การชนกัน") โอกาสที่จะเกิดการชนกันจะเพิ่มขึ้นเป็น 50% หลังจากสร้าง UUID 261 (2.3 x 10 ^ 18 หรือ 2.3 quintillion) แล้วเท่านั้น การเชื่อมโยงตัวเลขเหล่านี้กับฐานข้อมูลและเมื่อพิจารณาถึงปัญหาที่ว่าความน่าจะเป็นของการชนกันของ UUID เวอร์ชัน 4 นั้นเล็กน้อยหรือไม่ให้พิจารณาไฟล์ที่มี UUID เวอร์ชัน 4 จำนวน 2.3 quintillion ซึ่งมีโอกาส 50% ที่จะมีการชนกันของ UUID หนึ่งรายการ มันจะมีขนาด 36 เอ็กซาไบต์โดยสมมติว่าไม่มีข้อมูลหรือค่าใช้จ่ายอื่นใดที่ใหญ่กว่าฐานข้อมูลที่ใหญ่ที่สุดที่มีอยู่ในปัจจุบันหลายพันเท่าซึ่งเรียงตามลำดับเพตาไบต์ ในอัตรา 1 พันล้าน UUID ที่สร้างขึ้นต่อวินาทีจะใช้เวลา 73 ปีในการสร้าง UUID สำหรับไฟล์ นอกจากนี้ยังต้องใช้ประมาณ 3 ฮาร์ดไดรฟ์ขนาด 10 เทราไบต์ 6 ล้านตลับหรือตลับเทปเพื่อจัดเก็บโดยสมมติว่าไม่มีการสำรองข้อมูลหรือซ้ำซ้อน การอ่านไฟล์ที่อัตราการถ่ายโอน "disk-to-buffer" โดยทั่วไปคือ 1 กิกะบิตต่อวินาทีจะต้องใช้เวลามากกว่า 3000 ปีสำหรับโปรเซสเซอร์ตัวเดียว เนื่องจากอัตราความผิดพลาดในการอ่านที่ไม่สามารถกู้คืนได้ของไดรฟ์คือ 1 บิตต่อการอ่าน 1018 บิตอย่างดีที่สุดในขณะที่ไฟล์จะมีประมาณ 1,020 บิตการอ่านไฟล์เพียงครั้งเดียวจากต้นทางถึงปลายทางจะทำให้เกิดความผิดพลาดอย่างน้อยประมาณ 100 เท่า อ่าน UUID มากกว่ารายการที่ซ้ำกัน ข้อผิดพลาดในการจัดเก็บเครือข่ายพลังงานและฮาร์ดแวร์และซอฟต์แวร์อื่น ๆ จะเกิดขึ้นบ่อยกว่าปัญหาการทำสำเนา UUID หลายพันเท่า อัตราการถ่ายโอน 1 กิกะบิตต่อวินาทีจะต้องใช้เวลามากกว่า 3000 ปีสำหรับโปรเซสเซอร์ตัวเดียว เนื่องจากอัตราความผิดพลาดในการอ่านที่ไม่สามารถกู้คืนได้ของไดรฟ์คือ 1 บิตต่อการอ่าน 1018 บิตอย่างดีที่สุดในขณะที่ไฟล์จะมีประมาณ 1,020 บิตการอ่านไฟล์เพียงครั้งเดียวจากต้นทางถึงปลายทางจะทำให้เกิดความผิดพลาดอย่างน้อยประมาณ 100 เท่า อ่าน UUID มากกว่ารายการที่ซ้ำกัน ข้อผิดพลาดในการจัดเก็บเครือข่ายพลังงานและฮาร์ดแวร์และซอฟต์แวร์อื่น ๆ จะเกิดขึ้นบ่อยกว่าปัญหาการทำสำเนา UUID หลายพันเท่า อัตราการถ่ายโอน 1 กิกะบิตต่อวินาทีจะต้องใช้เวลามากกว่า 3000 ปีสำหรับโปรเซสเซอร์ตัวเดียว เนื่องจากอัตราความผิดพลาดในการอ่านที่ไม่สามารถกู้คืนได้ของไดรฟ์คือ 1 บิตต่อการอ่าน 1018 บิตอย่างดีที่สุดในขณะที่ไฟล์จะมีประมาณ 1,020 บิตการอ่านไฟล์เพียงครั้งเดียวจากต้นทางถึงปลายทางจะทำให้เกิดความผิดพลาดอย่างน้อยประมาณ 100 เท่า อ่าน UUID มากกว่ารายการที่ซ้ำกัน ข้อผิดพลาดในการจัดเก็บเครือข่ายพลังงานและฮาร์ดแวร์และซอฟต์แวร์อื่น ๆ จะเกิดขึ้นบ่อยกว่าปัญหาการทำสำเนา UUID หลายพันเท่า

ที่มา: wikipedia

สรุป,

• UUID เป็นมาตรฐาน
• gen_random_uuid()คือ 128 บิตสุ่มเก็บไว้ใน 128 บิต (2 ** 128 ชุดค่าผสม) 0- เสีย.
• random() สร้างเฉพาะ 52 บิตของการสุ่มใน PostgreSQL (2 ** 52 ชุดค่าผสม)
• md5()จัดเก็บเป็น UUID คือ 128 บิต แต่สามารถสุ่มได้เท่ากับอินพุตเท่านั้น ( 52 บิตหากใช้random() )
• md5()จัดเก็บเป็นข้อความคือ 288 บิต แต่สามารถสุ่มได้เฉพาะอินพุตเท่านั้น ( 52 บิตหากใช้random() ) - มากกว่าสองเท่าของขนาด UUID และเศษส่วนของการสุ่ม)
• md5() ในฐานะแฮชสามารถปรับให้เหมาะสมจนไม่สามารถทำอะไรได้มากนัก
• UUID มีประสิทธิภาพสูงสำหรับการจัดเก็บ: PostgreSQL จัดเตรียมประเภทที่มีขนาด 128 บิต ซึ่งแตกต่างจากtextและvarcharอื่น ๆ ที่จัดเก็บvarlenaซึ่งมีค่าโสหุ้ยสำหรับความยาวของสตริง
• PostgreSQL UUID ที่ดีมาพร้อมกับตัวดำเนินการการหล่อและคุณสมบัติเริ่มต้นบางอย่าง

เมื่อเร็ว ๆ นี้ฉันเล่นกับ PostgreSQL และฉันคิดว่าฉันได้พบวิธีแก้ปัญหาที่ดีกว่าเล็กน้อยโดยใช้วิธี PostgreSQL ในตัวเท่านั้น - ไม่มี pl / pgsql ข้อ จำกัด เพียงอย่างเดียวคือปัจจุบันสร้างเฉพาะสตริง UPCASE หรือตัวเลขหรือสตริงตัวพิมพ์เล็ก

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

อาร์กิวเมนต์ที่สองของgenerate_seriesวิธีการกำหนดความยาวของสตริง

กรุณาใช้string_agg!

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

ฉันใช้สิ่งนี้กับ MD5 เพื่อสร้าง UUID ด้วย ฉันแค่ต้องการค่าสุ่มที่มีบิตมากกว่าrandom ()จำนวนเต็ม

แม้ว่าจะไม่ได้ใช้งานตามค่าเริ่มต้นคุณสามารถเปิดใช้งานส่วนขยายหลักอย่างใดอย่างหนึ่ง:

CREATE EXTENSION IF NOT EXISTS pgcrypto;

จากนั้นคำสั่งของคุณจะกลายเป็นคำเรียกง่ายๆไปยัง gen_salt () ซึ่งสร้างสตริงแบบสุ่ม:

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

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

หมายเลขนำหน้าคือตัวระบุแฮช มีหลายอัลกอริทึมพร้อมตัวระบุของตัวเอง:

• md5: $ 1 $
• bf: $ 2a $ 06 $
• des: ไม่มีตัวระบุ
• xdes: _J9 ..

ข้อมูลเพิ่มเติมเกี่ยวกับส่วนขยาย:

• pgCrypto: http://www.postgresql.org/docs/9.2/static/pgcrypto.html
• ส่วนขยายที่รวม: http://www.postgresql.org/docs/9.2/static/contrib.html

แก้ไข

ตามที่ระบุโดย Evan Carrol ณ v9.4 คุณสามารถใช้ได้ gen_random_uuid()

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

ฉันไม่คิดว่าคุณกำลังมองหาสตริงสุ่มต่อ se สิ่งที่คุณต้องการสำหรับการตรวจสอบเซสชันคือสตริงที่รับประกันว่าไม่ซ้ำกัน คุณจัดเก็บข้อมูลการตรวจสอบเซสชันสำหรับการตรวจสอบหรือไม่? ในกรณีนี้คุณต้องให้สตริงไม่ซ้ำกันระหว่างเซสชัน ฉันรู้สองวิธีที่ค่อนข้างง่าย:

1. ใช้ลำดับ เหมาะสำหรับใช้กับฐานข้อมูลเดียว
2. ใช้ UUID ไม่เหมือนใครในระดับสากลเหมาะสำหรับสภาพแวดล้อมแบบกระจายเช่นกัน

UUIDs ได้รับการรับรองว่าไม่เหมือนใครโดยอาศัยอัลกอริทึมในการสร้าง อย่างมีประสิทธิภาพเป็นอย่างยิ่งไปได้ยากที่คุณจะสร้างตัวเลขที่เหมือนกันสองตัวบนเครื่องใดก็ได้ตลอดเวลา (โปรดทราบว่าสิ่งนี้แข็งแกร่งกว่าสตริงแบบสุ่มซึ่งมีระยะเวลาน้อยกว่า UUID มาก)

คุณต้องโหลดส่วนขยาย uuid-ossp เพื่อใช้ UUID เมื่อติดตั้งแล้วให้เรียกใช้ฟังก์ชัน uuid_generate_vXXX () ที่มีอยู่ในการโทร SELECT, INSERT หรือ UPDATE ประเภท uuid เป็นตัวเลข 16 ไบต์ แต่ยังมีการแทนค่าสตริงด้วย

พารามิเตอร์ INTEGER กำหนดความยาวของสตริง รับประกันว่าจะครอบคลุมอักขระที่เป็นตัวอักษรและตัวเลขทั้งหมด 62 ตัวโดยมีความน่าจะเป็นเท่ากัน (ไม่เหมือนกับโซลูชันอื่น ๆ ที่ลอยอยู่บนอินเทอร์เน็ต)

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 แนะนำการใช้pgcryptoแต่แทนที่จะgen_saltสิ่งที่เกี่ยวกับgen_random_bytes? แล้วsha512แทนที่จะเป็นmd5อย่างไร?

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

เอกสาร:

ฉ. 25.5. ฟังก์ชันสุ่มข้อมูล

gen_random_bytes (นับจำนวนเต็ม) ส่งคืนไบต์

ส่งคืนจำนวนไบต์สุ่มที่คาดเดายากที่เข้ารหัส สามารถแยกได้สูงสุด 1024 ไบต์ต่อครั้ง เพื่อหลีกเลี่ยงการระบายพูลตัวสร้างการสุ่ม

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

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