आप एक यादृच्छिक स्ट्रिंग कैसे बनाते हैं जो PostgreSQL में सत्र ID के लिए उपयुक्त है?

101

मैं PostgreSQL का उपयोग करके सत्र सत्यापन में उपयोग के लिए एक यादृच्छिक स्ट्रिंग बनाना चाहता हूं। मुझे पता है कि मैं एक यादृच्छिक संख्या प्राप्त कर सकता हूं SELECT random(), इसलिए मैंने कोशिश की SELECT md5(random()), लेकिन वह काम नहीं करता है। मैं यह कैसे कर सकता हूँ?

postgresql random

— Gersh
स्रोत

एक और समाधान यहां पाया जा सकता है stackoverflow.com/a/13675441/398670

— क्रेग रिंगर

7

मैंने शीर्षक संपादित किया है ताकि मौजूदा उत्तर अभी भी पूरी तरह से अच्छी समझ में आए, और इवान का जवाब चीजों को थोड़ा और आधुनिक रूप में अच्छी तरह से लाता है। मैं इस उम्र-पुराने प्रश्न को सामग्री विवाद के लिए लॉक नहीं करना चाहता - इसलिए कृपया सभी उत्तरों को समायोजित करते हुए कोई भी अतिरिक्त संपादन करें।

— टिम पोस्ट

1

कूल, आइए देखें कि क्या @gerh इस प्रश्न को स्पष्ट कर सकता है क्योंकि उसके मूल इरादे के अनुसार वैध असहमति है। अगर उसका मूल इरादा वही है जो मैं मानता हूं, तो इनमें से कई उत्तरों को समायोजित करने, नीचे करने या वापस लेने की आवश्यकता है। और, शायद परीक्षण के उद्देश्यों (या पसंद) के लिए तार पैदा करने के बारे में एक नया सवाल उठाया जाना चाहिए (जहां random()नेस आवश्यक नहीं है)। यदि यह वह नहीं है जो मैं मानता हूं, तो मेरे जवाब को परिष्कृत प्रश्न के बजाय पूरा करने की आवश्यकता है।

— इवान कैरोल

5

@ EvanCarroll - gersh को आखिरी बार 21 नवंबर 2015 को देखा गया था

— BSMP

5

वर्ष 2017 में इस प्रश्न पर आने वाले किसी व्यक्ति के लिए 2017 ईवान के उत्तर stackoverflow.com/a/41608000/190234 पर विचार करें क्योंकि यह उन तरीकों का उपयोग करता है जो तब उपलब्ध नहीं थे, जब सर्चियो nwas ने मूल रूप से पूछा और उत्तर दिया था।

— मार्सिन रेज़कोव्स्की

84

मैं यह सरल उपाय सुझाता हूँ:

यह एक बहुत ही सरल कार्य है जो दी गई लंबाई का एक यादृच्छिक स्ट्रिंग लौटाता है:

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)

— सिजमन लिपिस्की
स्रोत

6

यह समाधान वर्ण सरणी के किसी भी छोर पर मानों का उपयोग करता है - 0 और z - आधा शेष के रूप में अक्सर। वर्णों के और भी अधिक वितरण के लिए, मैंने प्रतिस्थापित chars[1+random()*(array_length(chars, 1)-1)]कियाchars[ceil(61 * random())]

— प्रीशियस

random()lengthकई बार (जैसे कई अन्य समाधानों में) कहा जाता है । क्या प्रत्येक बार 62 वर्णों से चुनने का अधिक कुशल तरीका है? इसकी तुलना में यह कैसा प्रदर्शन करता है md5()?

— ma11hew28

मुझे एक और उपाय मिला जो उपयोग करता है ORDER BY random()। कौन सा तेज है?

— 15:11 बजे ma11hew28

1

यह ध्यान देने योग्य है कि यादृच्छिक erand48 का उपयोग कर सकते हैं जो एक CSPRNG नहीं है, आप शायद सिर्फ pgcrypto का उपयोग करके बेहतर हैं।

— योर

2

इसके अलावा अच्छा जवाब यह सुरक्षित रैंडम नंबर जनरेटर का उपयोग नहीं करता है और इसलिए सत्र आईडी के लिए इतना अच्छा नहीं है। देखें: stackoverflow.com/questions/9816114/…

— sudo

240

आप अपने शुरुआती प्रयास को इस तरह से ठीक कर सकते हैं:

SELECT md5(random()::text);

कुछ अन्य सुझावों की तुलना में बहुत सरल। :-)

— पीटर आइसेनट्राट
स्रोत

16

ध्यान दें कि यह "हेक्स डिजिट्स अल्फाबेट" {0..9, a..f} पर ही रिटर्न करता है। पर्याप्त नहीं हो सकता - इस बात पर निर्भर करता है कि आप उनके साथ क्या करना चाहते हैं।

— लैरीक्स डेसीडुआ

लौटे स्ट्रिंग की लंबाई क्या है? वहाँ एक रास्ता बनाने के लिए यह एक लंबी स्ट्रिंग लौटा है?

— andrrk

8

जब हेक्साडेसिमल में प्रतिनिधित्व किया जाता है, तो एमडी 5 स्ट्रिंग की लंबाई हमेशा 32 वर्ण होती है। यदि आप लंबाई 64 की एक स्ट्रिंग चाहते हैं, तो आप 2 एमडी 5 तार को समतल कर सकते हैं: SELECT concat(md5(random()::text), md5(random()::text)); और यदि आप बीच में कहीं चाहते थे (उदाहरण के लिए 50 चार्ट), तो आप इसका एक विकल्प ले सकते हैं: SELECT substr(concat(md5(random()::text), md5(random()::text)), 0, 50);

— जिम्मी टाइरेल

2

सत्र आईडी के लिए बहुत अच्छा समाधान नहीं, बहुत यादृच्छिकता नहीं। जवाब भी 6 साल पुराना है। डेटाबेस में तेजी से, अधिक यादृच्छिकता, अधिक कुशलता से संग्रहीत: का उपयोग करके पूरी तरह से अलग विधि के लिए इसे देखेंgen_random_uuid() ।

— इवान कैरोल

@ इवान यदि आप बिना एक्सटेंशन के अधिक 'यादृच्छिकता' चाहते हैं SELECT md5(random()::text||random()::text);, याSELECT md5(random()::text||random()::text||random()::text);

31

मार्सिन के समाधान पर निर्माण, आप एक मनमाना वर्णमाला का उपयोग करने के लिए ऐसा कर सकते हैं (इस मामले में, सभी 62 ASCII अल्फ़ान्यूमेरिक वर्ण):

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

— grourk
स्रोत

धीमा, यादृच्छिक के रूप में, या स्टोर करने के लिए कुशल नहीं है। सत्र आईडी के लिए बहुत अच्छा समाधान नहीं, बहुत यादृच्छिकता नहीं। जवाब भी 6 साल पुराना है। Check out this for a totally different method using gen_random_uuid(): तेजी से, अधिक यादृच्छिकता, अधिक कुशलता से डेटाबेस में संग्रहीत।

— इवान कैरोल

23

आप एक यूयूआईडी से यादृच्छिक के 128 बिट प्राप्त कर सकते हैं। यह आधुनिक PostgreSQL में काम पाने की विधि है।

CREATE EXTENSION pgcrypto;
SELECT gen_random_uuid();

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

हो सकता है बहुत UUID पर डॉक्स पढ़ने लायक

डेटा प्रकार uuid RFC 4122, ISO / IEC 9834-8: 2005 और संबंधित मानकों द्वारा परिभाषित के रूप में यूनिवर्सली यूनिक आइडेंटिफायर (UUID) को स्टोर करता है । (कुछ सिस्टम इस डेटा प्रकार को एक विश्व स्तर पर विशिष्ट पहचानकर्ता, या GUID के बजाय संदर्भित करते हैं।) यह पहचानकर्ता 128-बिट मात्रा है जिसे एक एल्गोरिथ्म द्वारा उत्पन्न किया जाता है इसे बहुत ही संभावना नहीं है कि एक ही पहचानकर्ता किसी और द्वारा उत्पन्न किया जाएगा। एक ही एल्गोरिदम का उपयोग करके ज्ञात ब्रह्मांड में। इसलिए, वितरित प्रणालियों के लिए, ये पहचानकर्ता अनुक्रम जनरेटर की तुलना में एक बेहतर विशिष्टता की गारंटी प्रदान करते हैं, जो केवल एकल डेटाबेस के भीतर अद्वितीय हैं।

UUID के साथ टकराव कितना दुर्लभ है, या अनुमान लगाने योग्य है? मान लिया कि वे यादृच्छिक हैं,

लगभग 100 ट्रिलियन संस्करण 4 यूयूआईडी को एक एकल डुप्लिकेट ("टकराव") के एक अरब संभावना में 1 उत्पन्न करने की आवश्यकता होगी। 261 यूयूआईडी (2.3 x 10 ^ 18 या 2.3 क्विंटल) उत्पन्न होने के बाद ही एक टकराव की संभावना 50% तक बढ़ जाती है। इन नंबरों को डेटाबेस से संबंधित करना, और इस मुद्दे पर विचार करना कि क्या संस्करण 4 यूयूआईडी टकराव की संभावना नगण्य है, एक यूआईडीआईडी युक्त 50% संभावना के साथ 2.3 क्विंटलियन संस्करण 4 यूयूआईडी युक्त फ़ाइल पर विचार करें। यह आकार में 36 एक्साबाइट्स होगा, कोई अन्य डेटा या ओवरहेड नहीं मानते हुए, वर्तमान में मौजूद सबसे बड़े डेटाबेस की तुलना में हजारों गुना बड़ा है, जो पेटाबाइट्स के आदेश पर हैं। प्रति सेकंड उत्पन्न 1 बिलियन यूयूआईडी की दर से, फ़ाइल के लिए यूयूआईडी बनाने में 73 साल लगेंगे। इसके लिए भी लगभग 3 की आवश्यकता होगी। 6 मिलियन 10-टेराबाइट हार्ड ड्राइव या टेप कारतूस इसे स्टोर करने के लिए, कोई बैकअप या अतिरेक नहीं मानते हुए। एक विशिष्ट "डिस्क-टू-बफर" प्रति सेकंड 1 गीगाबिट की स्थानांतरण दर पर फ़ाइल को पढ़ने के लिए एक एकल प्रोसेसर के लिए 3000 से अधिक वर्षों की आवश्यकता होगी। चूँकि ड्राइव की अप्राप्य पढ़ने योग्य त्रुटि दर 1 बिट प्रति 1018 बिट्स पढ़ी जाती है, सबसे अच्छी तरह से, जबकि फ़ाइल में लगभग 1020 बिट्स होंगे, बस एक बार अंत से फ़ाइल को पढ़ने के परिणामस्वरूप, कम से कम, लगभग 100 गुना अधिक गलत परिणाम होंगे। डुप्लिकेट की तुलना में UUIDs पढ़ें। भंडारण, नेटवर्क, बिजली, और अन्य हार्डवेयर और सॉफ्टवेयर त्रुटियां निस्संदेह UUID दोहराव की समस्याओं की तुलना में हजारों गुना अधिक होगी। 1 गीगाबिट प्रति सेकंड की ट्रांसफर दर के लिए सिंगल प्रोसेसर के लिए 3000 से अधिक वर्षों की आवश्यकता होगी। चूँकि ड्राइव की अप्राप्य पढ़ने योग्य त्रुटि दर 1 बिट प्रति 1018 बिट्स पढ़ी जाती है, सबसे अच्छी तरह से, जबकि फ़ाइल में लगभग 1020 बिट्स होंगे, बस एक बार अंत से फ़ाइल को पढ़ने के परिणामस्वरूप, कम से कम, लगभग 100 गुना अधिक गलत परिणाम होंगे। डुप्लिकेट की तुलना में UUIDs पढ़ें। भंडारण, नेटवर्क, बिजली, और अन्य हार्डवेयर और सॉफ्टवेयर त्रुटियां निस्संदेह UUID दोहराव की समस्याओं की तुलना में हजारों गुना अधिक होगी। 1 गीगाबिट प्रति सेकंड की ट्रांसफर दर के लिए सिंगल प्रोसेसर के लिए 3000 से अधिक वर्षों की आवश्यकता होगी। चूँकि ड्राइव की अप्राप्य पढ़ने योग्य त्रुटि दर 1 बिट प्रति 1018 बिट्स पढ़ी जाती है, सबसे अच्छी तरह से, जबकि फ़ाइल में लगभग 1020 बिट्स होंगे, बस एक बार अंत से फ़ाइल को पढ़ने के परिणामस्वरूप, कम से कम, लगभग 100 गुना अधिक गलत परिणाम होंगे। डुप्लिकेट की तुलना में UUIDs पढ़ें। भंडारण, नेटवर्क, बिजली, और अन्य हार्डवेयर और सॉफ्टवेयर त्रुटियां निस्संदेह UUID दोहराव की समस्याओं की तुलना में हजारों गुना अधिक होगी।

स्रोत: विकिपीडिया

संक्षेप में,

यूयूआईडी मानकीकृत है।
gen_random_uuid()128 बिट्स (2 ** 128 संयोजनों) में यादृच्छिक के 128 बिट्स संग्रहीत हैं। 0-कचरा।
random() केवल PostgreSQL में यादृच्छिक के 52 बिट्स उत्पन्न करता है (2 ** 52 संयोजन)।
md5()यूयूआईडी के रूप में संग्रहीत 128 बिट्स हैं, लेकिन यह केवल इसके इनपुट के रूप में यादृच्छिक हो सकता है ( उपयोग करने पर 52 बिट्सrandom() )
md5()पाठ के रूप में संग्रहीत 288 बिट्स है, लेकिन यह केवल इसके इनपुट के रूप में यादृच्छिक हो सकता है ( 52 बिट्स का उपयोग करने परrandom() ) - एक यूयूआईडी के आकार और यादृच्छिकता के एक अंश के दोगुने से अधिक)
md5() एक हैश के रूप में, इतना अनुकूलित किया जा सकता है कि यह प्रभावी रूप से बहुत कुछ नहीं करता है।
UUID भंडारण के लिए अत्यधिक कुशल है: PostgreSQL एक प्रकार प्रदान करता है जो बिल्कुल 128 बिट्स है। इसके विपरीत textऔर varcharआदि, जो varlenaस्ट्रिंग की लंबाई के लिए ओवरहेड के रूप में स्टोर होता है।
PostgreSQL निफ्टी यूयूआईडी कुछ डिफ़ॉल्ट ऑपरेटरों, कास्टिंग और सुविधाओं के साथ आता है।

— इवान कैरोल
स्रोत

3

आंशिक रूप से गलत: एक ठीक से उत्पन्न यादृच्छिक यूयूआईडी में केवल 122 यादृच्छिक बिट्स हैं क्योंकि संस्करण के लिए 4 बिट्स का उपयोग किया जाता है और संस्करण के लिए 2 बिट्स: en.wikipedia.org/wiki/…

— Olivier Grégoire

2

यदि स्रोत ऐसा नहीं करता है जो वहां लिखा गया है, तो यह यूयूआईडी नहीं है और इसे पोस्टग्रेक्यूएल द्वारा नहीं कहा जाना चाहिए।

— ओलिवियर

16

मैं हाल ही में 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विधि का दूसरा तर्क स्ट्रिंग की लंबाई निर्धारित करता है।

— मार्सिन रेज़कोव्स्की
स्रोत

8

मुझे यह पसंद है, लेकिन जब मैंने इसे एक अद्यतन कथन का उपयोग किया, तो पाया कि सभी पंक्तियाँ अद्वितीय पासवर्ड के बजाय उसी यादृच्छिक पासवर्ड पर सेट की गई थीं। मैंने प्राथमिक कुंजी आईडी को सूत्र में जोड़कर इसे हल किया। मैं इसे यादृच्छिक मूल्य में जोड़ता हूं और इसे फिर से घटाता हूं। यादृच्छिकता को परिवर्तित नहीं किया गया है, लेकिन PostgreSQL को प्रत्येक पंक्ति के लिए मानों को पुन: गणना करने में धोखा दिया जाता है। यहां एक उदाहरण है, "my_id" के प्राथमिक कुंजी नाम का उपयोग करते हुए: array_to_string(ARRAY(SELECT chr((65 + round((random()+my_id-my) * 25)) :: integer) FROM generate_series(1,8)), '')

— मार्क स्टोसबर्ग 19

समाधान, जो @MarkStosberg ने प्रस्तुत किया, जैसा उन्होंने कहा था, वैसे ही काम किया, लेकिन जैसा कि मुझे उम्मीद थी; उत्पादित डेटा प्रीकेटेड पैटर्न (सिर्फ अक्षर का मामला या सिर्फ अंक) से मेल नहीं खाता। मैं यादृच्छिक परिणाम को अंकगणित द्वारा तय:

array_to_string(ARRAY(SELECT chr((65 + round((random() * 25 + id) :: integer % 25 )) :: integer) FROM generate_series(1, 60)), '');

— नूनो राफेल Figueiredo

4

नहीं, आप जवाब दे रहे हैं 'मैं कैसे यादृच्छिक उत्पन्न करता हूं सेशन आईडी कैसे जनरेट करता हूँ' नहीं 'मैं रैंडम स्ट्रिंग कैसे जेनरेट करता हूँ '। आपने वर्णन में दो शब्दों के आधार पर क्सेटिटॉन (और शीर्षक) का अर्थ बदल दिया है। आप अलग सवाल का जवाब दे रहे हैं। और सवाल को अर्थ बदलने के लिए अपनी संयम शक्ति का दुरुपयोग करते रहें।

— मार्सिन रेज़कोव्स्की 20

13

कृपया उपयोग करें string_agg!

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

मैं एक UUID भी उत्पन्न करने के लिए MD5 के साथ इसका उपयोग कर रहा हूं। मुझे बस एक random ()पूर्णांक से अधिक बिट्स के साथ एक यादृच्छिक मूल्य चाहिए ।

— एंड्रयू वोल्फ
स्रोत

मुझे लगता है कि random()जब तक मुझे बिट्स की संख्या नहीं मिल जाती, तब तक मैं सिर्फ कॉन्फेटनेट कर सकता हूं। ओह अच्छा।

— एंड्रयू वुल्फ

11

डिफ़ॉल्ट रूप से सक्रिय नहीं रहते हुए, आप मुख्य एक्सटेंशन में से एक को सक्रिय कर सकते हैं:

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

संपादित करें

जैसा कि इवान कारोल ने संकेत दिया है, v9.4 के रूप में आप उपयोग कर सकते हैं gen_random_uuid()

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

— जेफरी गुफा
स्रोत

उत्पन्न लवण वास्तव में यादृच्छिक होने के लिए बहुत अनुक्रमिक लगते हैं, है ना?

— ले ड्रॉइड

1

क्या आप इसका जिक्र कर रहे हैं $1$ ? यह एक हैश प्रकार का पहचानकर्ता (md5 == 1) है, बाकी यादृच्छिक मूल्य है।

— जेफरी गुफा

हां, यह मेरी गलत व्याख्या थी, सटीक के लिए धन्यवाद।

— ले ड्रॉइड

6

मुझे नहीं लगता है कि आप प्रति यादृच्छिक यादृच्छिक स्ट्रिंग की तलाश कर रहे हैं। सत्र सत्यापन के लिए आपको जो कुछ चाहिए वह एक स्ट्रिंग है जो अद्वितीय होने की गारंटी है। क्या आप ऑडिटिंग के लिए सत्र सत्यापन जानकारी संग्रहीत करते हैं? उस स्थिति में आपको सत्र के बीच अद्वितीय होने के लिए स्ट्रिंग की आवश्यकता होती है। मुझे दो का पता है, बल्कि सरल दृष्टिकोण:

एक क्रम का उपयोग करें। एकल डेटाबेस पर उपयोग के लिए अच्छा है।
एक UUID का उपयोग करें। विश्व स्तर पर अद्वितीय, वितरित वातावरण पर भी अच्छा है।

UUIDs पीढ़ी के लिए अपने एल्गोरिथ्म के आधार पर अद्वितीय होने की गारंटी देते हैं; प्रभावी रूप से यह अत्यंत है कम संभावना है कि आप किसी भी समय किसी भी मशीन पर दो समान संख्याएं उत्पन्न करेंगे, कभी भी ध्यान दें (यह यादृच्छिक स्ट्रिंग्स की तुलना में बहुत मजबूत है, जिसमें यूयूआईडी की तुलना में कहीं अधिक छोटी अवधि है)।

UUID का उपयोग करने के लिए आपको uuid-ossp एक्सटेंशन लोड करना होगा। इंस्टॉल हो जाने के बाद, किसी भी उपलब्ध uuid_generate_vXXX () फ़ंक्शन को अपने SELECT, INSERT या UPDATE कॉल में कॉल करें। Uuid प्रकार एक 16-बाइट अंक है, लेकिन इसमें एक स्ट्रिंग प्रतिनिधित्व भी है।

— पैट्रिक
स्रोत

यह संभावित खतरनाक सलाह की तरह लगता है। जब यह सत्र कुंजी की बात आती है, तो आप विशिष्टता और यादृच्छिकता चाहते हैं जो क्रिप्टोग्राफिक रूप से यादृच्छिक रूप से पर्याप्त है ताकि इसे अनुमान लगाने के किसी भी उचित अवसर को छोड़ दें। यूयूआईडी द्वारा उपयोग किए गए एल्गोरिदम गैर-यादृच्छिक (अधिकतर) तंत्रों द्वारा विशिष्टता की गारंटी देते हैं, जो सुरक्षा के लिए खतरा पैदा करता है।

— jmar777

6

@ jmar777 UUIDs का पूरा उद्देश्य यह है कि वे अनुमान लगाना मुश्किल हैं और अत्यधिक यादृच्छिक हैं। V1 संस्करण को छोड़कर उनके पास बहुत अधिक आवधिकता है; v4 पूरी तरह से 128-बिट यादृच्छिक है। उनका उपयोग आपके द्वारा किए जाने वाले प्रत्येक ऑनलाइन बैंकिंग लेनदेन में किया जा रहा है। अगर वे इसके लिए पर्याप्त हैं, तो वे बहुत ज्यादा कुछ भी के लिए काफी अच्छे हैं।

— पैट्रिक

1

ठीक है, आप क्या जानते हो। मुझे नहीं पता था कि संस्करण 4 में संबोधित किया गया था । मुझे सही करने के लिए धन्यवाद!

— jmar777

@ पैट्रिक स्मॉल नाइट, V4 UUIDs 122 बिट्स के रैंडम हैं, 128 के नहीं हैं;)

— जेसी

5

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;

— लेरिक्स डिकिडुआ
स्रोत

धीमा, यादृच्छिक के रूप में, या स्टोर करने के लिए कुशल नहीं है। सत्र आईडी के लिए बहुत अच्छा समाधान नहीं, बहुत यादृच्छिकता नहीं। जवाब भी 6 साल पुराना है। Check out this for a totally different method using gen_random_uuid(): तेजी से, अधिक यादृच्छिकता, अधिक कुशलता से डेटाबेस में संग्रहीत।

— इवान कैरोल

3

@EvanCarroll: सभी निष्पक्षता में, gen_random_uuid()संस्करण 9.4 में दिखाई दिया , जहां तक मैं बता सकता हूं, जो 2014-12-18 जारी किया गया था, एक साल से अधिक समय के बाद आपको जवाब देना पड़ा। अतिरिक्त नाइटपिक: इसका उत्तर केवल 3 1/2 साल पुराना है। लेकिन आप सही हैं, अब हमारे पास यही है gen_random_uuid(), इसका उपयोग किया जाना चाहिए। इसलिए मैं आपका जवाब दूंगा।

— लेरिक्स डेसीडुआ

5

@ कैवियस का उपयोग करने की सिफारिश की pgcrypto, लेकिन इसके बजाय gen_salt, किस बारे में gen_random_bytes? और कैसे के sha512बजाय के बारे में md5?

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

डॉक्स:

F.25.5। रैंडम-डेटा फ़ंक्शंस

gen_random_bytes (पूर्णांक गिनें) प्रतिफल देता है

रिटर्न क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक बाइट्स की गणना करता है। एक बार में अधिकतम 1024 बाइट्स निकाले जा सकते हैं। यह यादृच्छिकता जनरेटर पूल से बचने से है।

— जारेड बेक
स्रोत

4

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

— user516487
स्रोत

2

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

— user457226
स्रोत

मैं इसे फॉरवर्ड-स्लैश और प्लस साइन को हटाने के लिए संशोधित करता हूं जो कभी-कभी परिणाम में दिखाई देता है और अपरकेस परिणाम उत्पन्न करने के लिए ऊपरी (रिप्लेसमेंट (प्रतिस्थापन (एनकोड) (डीकोड 5 (यादृच्छिक) :: पाठ)), हेक्स का चयन करें ') || डीकोड (md5 (यादृच्छिक () :: टेक्स्ट),' हेक्स '),' बेस 64 '), 0, 10),' / ',' ए '),' + ',' जेड '));

— सीन मैट