यूएलआईडी जेनरेटर

ULID क्या है?

ULID (Universally Unique Lexicographically Sortable Identifier) एक 26-अक्षरों वाला कोड है, जिसका उपयोग डेटाबेस में रिकॉर्ड या वितरित प्रणाली में किसी घटना को चिह्नित करने के लिए किया जाता है। यह वर्तमान समय को यादृच्छिक डेटा के साथ जोड़ता है, इसलिए वर्णानुक्रम में क्रमबद्ध की गई ULID की सूची प्रत्येक ULID के बनाए जाने के समय के क्रम में भी होती है। ULID जनरेटर ऐसा उपकरण है जो ये कोड बनाता है।

ULID की संरचना

ULID के दो भाग होते हैं, जो बिना किसी विभाजक के एक के बाद एक लिखे जाते हैं:

टाइमस्टैम्प (10 अक्षर): 1 जनवरी 1970 से बीत चुके मिलीसेकंड की संख्या (Unix epoch), जो अधिकतम 48 बिट तक होती है।
यादृच्छिकता (16 अक्षर): 80 बिट का यादृच्छिक डेटा, ताकि एक ही मिलीसेकंड में बनाई गई दो ULID के अलग होने की लगभग पूरी निश्चितता रहे।

दोनों भाग Crockford के Base32 वर्णमाला का उपयोग करके लिखे जाते हैं: अंक 0–9 और A-Z के अक्षर, लेकिन I, L, O और U अक्षरों को छोड़कर। इन चार अक्षरों को इसलिए हटाया गया है क्योंकि इन्हें अंक 0 और 1 या एक-दूसरे के लिए गलती से पढ़ा जा सकता है। परिणामस्वरूप बनी स्ट्रिंग छोटी, ज़ोर से पढ़ने में आसान और सीधे URL में रखने के लिए सुरक्षित होती है।

ULID की गणना कैसे करें

ULID जनरेटर तीन चरणों में एक पहचानकर्ता बनाता है।

वर्तमान समय पढ़ें और उसे Unix epoch से बीते मिलीसेकंड में व्यक्त करें। यह 48-बिट संख्या होती है।
80 बिट का यादृच्छिक डेटा उत्पन्न करें, सामान्यतः क्रिप्टोग्राफ़िक रूप से सुरक्षित यादृच्छिक संख्या जनरेटर से, जिससे 10 यादृच्छिक बाइट मिलते हैं।
दोनों भागों को अलग-अलग एन्कोड करें और Crockford की Base32 वर्णमाला का उपयोग करें: 48-बिट टाइमस्टैम्प 10 अक्षरों में बदलता है और 80-बिट यादृच्छिक मान 16 अक्षरों में। अंतिम 26-अक्षरों वाली ULID बनाने के लिए दोनों एन्कोड की गई स्ट्रिंग को जोड़ दिया जाता है।

एन्कोडिंग में संख्या को एक बार में 5 बिट पढ़ा जाता है, क्योंकि प्रत्येक Base32 अक्षर 32 संभावित मानों में से एक का प्रतिनिधित्व करता है (2^5 = 32)। दस अक्षरों में अधिकतम 50 बिट रखे जा सकते हैं, जो 48-बिट टाइमस्टैम्प के लिए पर्याप्त हैं। सोलह अक्षरों में ठीक 80 बिट होते हैं, जो यादृच्छिकता वाले भाग से पूरी तरह मेल खाते हैं और कुछ भी शेष नहीं रहता।

उदाहरण सहित गणना

मान लें कि ULID जनरेटर टाइमस्टैम्प 1712345678901 पर चलता है (epoch से बीते मिलीसेकंड) और यादृच्छिक बाइट [12, 240, 88, 3, 199, 45, 6, 231, 128, 17] प्राप्त करता है।

चरण 1 – टाइमस्टैम्प को एन्कोड करें। 1712345678901 को बार-बार 32 से भाग दें, हर बार शेषफल लें और अंकों को अंतिम से पहले तक पढ़ें (यह मानक बेस रूपांतरण है)। इससे 10-अक्षरों वाली स्ट्रिंग 01HTQW311N प्राप्त होती है।

चरण 2 – यादृच्छिकता को एन्कोड करें। 10 यादृच्छिक बाइट को 80 बिट की धारा में पैक करें, फिर एक बार में 5 बिट पढ़ें और प्रत्येक 5-बिट खंड को Base32 अक्षर में बदलें। इससे 16-अक्षरों वाली स्ट्रिंग 1KR5G0Y75M3EF00H प्राप्त होती है।

चरण 3 – भागों को जोड़ें। अंतिम ULID है:

101HTQW311N 1KR5G0Y75M3EF00H
2

बिना रिक्ति के लिखने पर: 01HTQW311N1KR5G0Y75M3EF00H, कुल 26 अक्षर।

इस जनरेटर का उपयोग

जनरेटर ब्राउज़र में चलता है। प्रत्येक ULID ब्राउज़र की घड़ी और ब्राउज़र के क्रिप्टोग्राफ़िक यादृच्छिक संख्या जनरेटर से लिए गए 80 नए यादृच्छिक बिट से बनाई जाती है, इसलिए कोई भी पहचानकर्ता सर्वर को भेजा या सर्वर से प्राप्त नहीं किया जाता।

ULID की संख्या 1 से 50 तक की पूर्ण संख्या स्वीकार करती है। डिफ़ॉल्ट मान 1 है।
ULID उत्पन्न करें एक नया बैच बनाता है। संख्या बदलने पर भी नया बैच बनता है।
किसी परिणाम पर कॉपी करें उस एक ULID की प्रतिलिपि बनाता है। एक से अधिक ULID दिखने पर सभी कॉपी करें पूरी सूची की, प्रत्येक पंक्ति में एक ULID की, प्रतिलिपि बनाता है।
रीसेट करें संख्या को वापस 1 पर सेट करता है और एक नई ULID बनाता है।

परिणामों के नीचे, ULID संरचना पैनल बैच की पहली ULID को उसके दो भागों में बाँटता है: पहले 10 अक्षर (टाइमस्टैम्प) और अंतिम 16 अक्षर (यादृच्छिकता)।

ULID बनाम UUID

विशेषता	ULID	UUID (संस्करण 4)
लंबाई	26 अक्षर	36 अक्षर (हाइफ़न सहित)
निर्माण समय के अनुसार क्रमबद्ध	हाँ	नहीं
एन्कोडिंग	Crockford Base32	हेक्साडेसिमल
टाइमस्टैम्प शामिल है	हाँ (48 बिट)	नहीं
एस्केपिंग के बिना URL-सुरक्षित	हाँ	हाँ

दोनों प्रारूप किसी केंद्रीय प्राधिकरण द्वारा संख्याएँ बाँटे बिना ऐसी पहचान बनाने का लक्ष्य रखते हैं, जो विभिन्न प्रणालियों में अद्वितीय हों। व्यावहारिक मुख्य अंतर क्रमबद्धता का है: ULID की शुरुआत टाइमस्टैम्प से होती है, इसलिए ULID को साधारण पाठ के रूप में क्रमबद्ध करने पर वे समय के अनुसार भी क्रमबद्ध हो जाती हैं। यादृच्छिक UUID में यह गुण नहीं होता, क्योंकि उसका प्रत्येक भाग यादृच्छिक होता है।

सामान्य उपयोग

डेटाबेस प्राथमिक कुंजियाँ: ULID डेटाबेस में नई पंक्तियों को लगभग उसी क्रम में अनुक्रमित करने देती हैं, जिस क्रम में वे डाली गई थीं। कई डेटाबेस इंजन इसे पूरी तरह यादृच्छिक कुंजियों की तुलना में अधिक कुशलता से संभालते हैं।
वितरित प्रणालियाँ: अलग-अलग सर्वर किसी केंद्रीय काउंटर के साथ समन्वय किए बिना स्वतंत्र रूप से ULID बना सकते हैं और परिणामों के अद्वितीय होने की लगभग पूरी निश्चितता रहती है।
घटना लॉग: ULID समय के अनुसार क्रमबद्ध होती हैं, इसलिए घटना ID की सूची मोटे तौर पर समयरेखा का काम कर सकती है।
API और फ़ाइल पहचानकर्ता: निश्चित 26-अक्षरों वाला, URL-सुरक्षित प्रारूप वेब पतों और फ़ाइल नामों में आसानी से काम करता है।

संबंधित पहचानकर्ता प्रारूपों में KSUID शामिल है, जो क्रमबद्धता के लिए टाइमस्टैम्प को भी एन्कोड करता है, और Snowflake ID, जिनका उपयोग Twitter तथा अन्य संस्थाएँ करती हैं और जो टाइमस्टैम्प, मशीन पहचानकर्ता और काउंटर को जोड़ते हैं।

कोड उदाहरण

नीचे दिया गया प्रत्येक उदाहरण ULID विनिर्देश में बताए गए तरीके से ULID बनाता है: 48-बिट टाइमस्टैम्प को 10 Crockford Base32 अक्षरों में एन्कोड करना, 80 बिट की यादृच्छिकता को 16 और अक्षरों में एन्कोड करना और दोनों को जोड़ना।

JavaScript

1const ENCODING_CHARS = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
2
3function encodeULID(time, randomBytes) {
4  // Timestamp: 48 bits -> 10 characters
5  let timestampStr = '';
6  let t = time;
7  for (let i = 0; i < 10; i++) {
8    timestampStr = ENCODING_CHARS[t % 32] + timestampStr;
9    t = Math.floor(t / 32);
10  }
11
12  // Randomness: 80 bits -> 16 characters
13  let result = timestampStr;
14  let bits = 0;
15  let bitCount = 0;
16  for (let i = 0; i < 10; i++) {
17    bits = (bits << 8) | randomBytes[i];
18    bitCount += 8;
19    while (bitCount >= 5) {
20      bitCount -= 5;
21      result += ENCODING_CHARS[(bits >> bitCount) & 0x1f];
22    }
23  }
24  return result;
25}
26
27function generateULID() {
28  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
29  return encodeULID(Date.now(), randomBytes);
30}
31
32console.log(generateULID());
33

Python

1import os
2import time
3
4ENCODING_CHARS = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
5
6def encode_ulid(time_ms, random_bytes):
7    # Timestamp: 48 bits -> 10 characters
8    chars = []
9    t = time_ms
10    for _ in range(10):
11        chars.append(ENCODING_CHARS[t % 32])
12        t //= 32
13    timestamp_part = "".join(reversed(chars))
14
15    # Randomness: 80 bits -> 16 characters
16    bits = 0
17    bit_count = 0
18    random_part = []
19    for byte in random_bytes:
20        bits = (bits << 8) | byte
21        bit_count += 8
22        while bit_count >= 5:
23            bit_count -= 5
24            random_part.append(ENCODING_CHARS[(bits >> bit_count) & 0x1F])
25
26    return timestamp_part + "".join(random_part)
27
28def generate_ulid():
29    return encode_ulid(int(time.time() * 1000), os.urandom(10))
30
31print(generate_ulid())
32

Java

1import java.security.SecureRandom;
2import java.time.Instant;
3
4public class ULIDGenerator {
5    private static final SecureRandom random = new SecureRandom();
6    private static final char[] ENCODING_CHARS =
7        "0123456789ABCDEFGHJKMNPQRSTVWXYZ".toCharArray();
8
9    public static String generateULID() {
10        long timestamp = Instant.now().toEpochMilli();
11        byte[] randomBytes = new byte[10];
12        random.nextBytes(randomBytes);
13
14        // Timestamp: 48 bits -> 10 characters
15        char[] timestampChars = new char[10];
16        long t = timestamp;
17        for (int i = 9; i >= 0; i--) {
18            timestampChars[i] = ENCODING_CHARS[(int) (t % 32)];
19            t /= 32;
20        }
21
22        // Randomness: 80 bits -> 16 characters
23        StringBuilder result = new StringBuilder(new String(timestampChars));
24        long bits = 0;
25        int bitCount = 0;
26        for (byte b : randomBytes) {
27            bits = (bits << 8) | (b & 0xFF);
28            bitCount += 8;
29            while (bitCount >= 5) {
30                bitCount -= 5;
31                result.append(ENCODING_CHARS[(int) ((bits >> bitCount) & 0x1F)]);
32            }
33        }
34        return result.toString();
35    }
36
37    public static void main(String[] args) {
38        System.out.println(generateULID());
39    }
40}
41

अक्सर पूछे जाने वाले प्रश्न

ULID का उपयोग किस लिए किया जाता है? ULID का उपयोग डेटाबेस पंक्ति, API संसाधन या लॉग की गई घटना के लिए अद्वितीय पहचानकर्ता के रूप में किया जाता है, जब निर्माण समय के अनुसार क्रमबद्ध करना भी उपयोगी हो।

ULID कितनी लंबी होती है? ULID हमेशा 26 अक्षरों की होती है: टाइमस्टैम्प के लिए 10 अक्षर और यादृच्छिक भाग के लिए 16 अक्षर।

ULID किस एन्कोडिंग का उपयोग करती है? ULID Crockford की Base32 वर्णमाला का उपयोग करती है, जिसमें अंक 0–9 और A-Z के अक्षर होते हैं, लेकिन अन्य अक्षरों से भ्रम से बचने के लिए I, L, O और U हटा दिए गए हैं।

ULID, UUID से कैसे अलग है? ULID निर्माण समय के अनुसार क्रमबद्ध होती है और 26 अक्षरों की होती है। यादृच्छिक (संस्करण 4) UUID समय के अनुसार क्रमबद्ध नहीं होती और हाइफ़न सहित 36 अक्षरों की होती है।

दो ULID के बीच टकराव की संभावना कितनी है? 80 बिट की यादृच्छिकता टकराव की संभावना को अत्यंत कम कर देती है। एक ही मिलीसेकंड में लगभग 1.3 ट्रिलियन ULID बनानी होंगी, ताकि किसी भी दो के समान होने की संभावना 50% तक पहुँचे।

क्या ULID इंटरनेट कनेक्शन के बिना बनाई जा सकती हैं? हाँ। ULID के लिए केवल स्थानीय घड़ी और यादृच्छिक संख्या जनरेटर चाहिए, इसलिए इसे पूरी तरह ऑफ़लाइन बनाया जा सकता है।

संदर्भ

"ULID Specification." GitHub, https://github.com/ulid/spec.
"Crockford's Base32 Encoding." http://www.crockford.com/base32.html.

यूएलआईडी जेनरेटर - ऑनलाइन मुफ्त अद्वितीय क्रमबद्ध आईडी बनाएं

दस्तावेज़ीकरण