ULID ಜನರೇಟರ್

ಪರಿಚಯ

ULID (ಸಾರ್ವಜನಿಕವಾಗಿ ವಿಶಿಷ್ಟ ಲೆಕ್ಸಿಕೋಗ್ರಾಫಿಕಲ್ ಶ್ರೇಣೀಬದ್ಧ ಗುರುತಿನ ಸೂಚಕ) ಒಂದು ವಿಶಿಷ್ಟ ಗುರುತಿನ ಸೂಚಕವಾಗಿದೆ, ಇದು ಸಮಯವನ್ನು ಯಾದೃಚ್ಛಿಕ ಡೇಟಾದೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ ಮತ್ತು 26-ಅಕ್ಷರದ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ULIDs ಶ್ರೇಣೀಬದ್ಧವಾಗಿರುವುದಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಜೊತೆಗೆ ವಿಶಿಷ್ಟತೆ ಮತ್ತು ಯಾದೃಚ್ಛಿಕತೆಯ ಹೆಚ್ಚಿನ ಮಟ್ಟವನ್ನು ಕಾಯ್ದುಕೊಳ್ಳುತ್ತದೆ.

ULID ರಚನೆ

ULID ಎರಡು ಮುಖ್ಯ ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

1. ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ (10 ಅಕ್ಷರಗಳು): ಮೊದಲ 10 ಅಕ್ಷರಗಳು ಯುನಿಕ್ಸ್ ಎಪೋಚ್ (1970-01-01) ನಂತರದ ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ಸಮಯವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.
2. ಯಾದೃಚ್ಛಿಕತೆ (16 ಅಕ್ಷರಗಳು): ಉಳಿದ 16 ಅಕ್ಷರಗಳನ್ನು ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕಲ್ ಸುರಕ್ಷಿತ ಯಾದೃಚ್ಛಿಕ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಲಾಗುತ್ತದೆ.

ಫಲಿತಾಂಶವಾಗಿ 26-ಅಕ್ಷರದ ಶ್ರೇಣಿಯನ್ನು ಕ್ರಾಕ್‌ಫೋರ್ಡ್‌ನ ಬೇಸ್32 ಅಲ್ಫಾಬೆಟ್ (0-9 ಮತ್ತು A-Z, I, L, O, ಮತ್ತು U ಅನ್ನು ಹೊರತುಪಡಿಸಿ) ಬಳಸಿಕೊಂಡು ಎನ್‌ಕೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ.

ಸೂತ್ರ

ULID ಅನ್ನು ಈ ಕೆಳಗಿನ ಹಂತಗಳನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಲಾಗುತ್ತದೆ:

1. 48-ಬಿಟ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ರಚಿಸಿ (ಯುನಿಕ್ಸ್ ಎಪೋಚ್ ನಂತರದ ಮಿಲಿಸೆಕೆಂಡುಗಳು).
2. ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕಲ್ ಸುರಕ್ಷಿತ ಯಾದೃಚ್ಛಿಕ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು 80 ಬಿಟ್‌ಗಳನ್ನು ರಚಿಸಿ.
3. ಕ್ರಾಕ್‌ಫೋರ್ಡ್‌ನ ಬೇಸ್32 ಎನ್‌ಕೋಡಿಂಗ್ ಬಳಸಿಕೊಂಡು ಸಂಯೋಜಿತ 128 ಬಿಟ್‌ಗಳನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡಿ.

ಲೆಕ್ಕಹಾಕುವುದು

ULID ಜನರೇಟರ್ ಈ ಕೆಳಗಿನ ಹಂತಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:

1. ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ಪ್ರಸ್ತುತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಪಡೆಯಿರಿ.
2. ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕಲ್ ಸುರಕ್ಷಿತ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯಾ ಜನರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು 10 ಯಾದೃಚ್ಛಿಕ ಬೈಟ್‌ಗಳನ್ನು (80 ಬಿಟ್‌ಗಳು) ರಚಿಸಿ.
3. ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಮತ್ತು ಯಾದೃಚ್ಛಿಕ ಡೇಟಾವನ್ನು 128-ಬಿಟ್ ಪೂರ್ಣಾಂಕದಲ್ಲಿ ಸಂಯೋಜಿಸಿ.
4. ಕ್ರಾಕ್‌ಫೋರ್ಡ್‌ನ ಬೇಸ್32 ಎನ್‌ಕೋಡಿಂಗ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು 128-ಬಿಟ್ ಪೂರ್ಣಾಂಕವನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡಿ.

ಬಳಕೆದಾರಿಕೆಗಳು

ULIDs ವಿವಿಧ ದೃಶ್ಯಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿವೆ, ಒಳಗೊಂಡಂತೆ:

1. ಡೇಟಾಬೇಸ್ ಕೀಗಳು: ULIDs ಅನ್ನು ಡೇಟಾಬೇಸ್ ದಾಖಲೆಗಳಿಗೆ ವಿಶಿಷ್ಟ ಗುರುತಿನ ಸೂಚಕಗಳಾಗಿ ಬಳಸಬಹುದು, ವಿಶೇಷವಾಗಿ ವಿಶಿಷ್ಟತೆ ಮತ್ತು ಶ್ರೇಣೀಬದ್ಧತೆಯನ್ನು ಖಚಿತಪಡಿಸಲು.
2. ವಿತರಿತ ವ್ಯವಸ್ಥೆಗಳು: ವಿತರಿತ ಪರಿಸರದಲ್ಲಿ, ULIDs ಅನ್ನು ನೋಡ್‌ಗಳ ನಡುವಿನ ಸಹಕಾರವಿಲ್ಲದೆ ರಚಿಸಬಹುದು.
3. ಲಾಗಿಂಗ್ ಮತ್ತು ಟ್ರೇಸಿಂಗ್: ULIDs ಅನ್ನು ಲಾಗ್ ಎಂಟ್ರಿಗಳನ್ನು ಟ್ಯಾಗ್ ಮಾಡಲು ಅಥವಾ ಘಟನೆಗಳನ್ನು ಟ್ರೇಸ್ ಮಾಡಲು ಬಳಸಬಹುದು, ಶ್ರೇಣೀಬದ್ಧ ಮತ್ತು ವಿಶಿಷ್ಟ ಗುರುತಿನ ಸೂಚಕವನ್ನು ಒದಗಿಸುತ್ತವೆ.
4. URL-ಹಿತ IDs: ULIDs URL-ಸುರಕ್ಷಿತವಾಗಿವೆ ಮತ್ತು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ URLs ನಲ್ಲಿ ಗುರುತಿನ ಸೂಚಕಗಳಾಗಿ ಬಳಸಬಹುದು.

ಪರ್ಯಾಯಗಳು

ULIDs ಬಹುಮುಖವಾಗಿರುವಾಗ, ಪರಿಗಣಿಸಲು ಇತರ ವಿಶಿಷ್ಟ ಗುರುತಿನ ವ್ಯವಸ್ಥೆಗಳಿವೆ:

1. UUID (ಸಾರ್ವಜನಿಕವಾಗಿ ವಿಶಿಷ್ಟ ಗುರುತಿನ ಸೂಚಕ): ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಘಟಕವನ್ನು ಒಳಗೊಂಡಿಲ್ಲದ 128-ಬಿಟ್ ಗುರುತಿನ ಸೂಚಕ.
2. KSUID (K-ಶ್ರೇಣೀಬದ್ಧ ವಿಶಿಷ್ಟ ಗುರುತಿನ ಸೂಚಕ): ULID ಗೆ ಹೋಲಿಸಿದಂತೆ ಆದರೆ ವಿಭಿನ್ನ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಎನ್‌ಕೋಡಿಂಗ್ ಅನ್ನು ಹೊಂದಿದೆ.
3. ಸ್ನೋಫ್ಲೇಕ್ ID: ಟ್ವಿಟ್ಟರ್‌ನ ವಿತರಿತ ವಿಶಿಷ್ಟ ID ಜನರೇಶನ್ ವ್ಯವಸ್ಥೆ, ಇದು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಮತ್ತು ವರ್ಕರ್ ID ಅನ್ನು ಒಳಗೊಂಡಿದೆ.

ಇತಿಹಾಸ

ULIDs 2016ರಲ್ಲಿ ಅಲಿಜೈನ್ ಫೀರಾಸ್ಟಾ ಮೂಲಕ UUIDಗಳಿಗೆ ಪರ್ಯಾಯವಾಗಿ ಪರಿಚಯಿಸಲಾಯಿತು. ಶ್ರೇಣೀಬದ್ಧತೆ ಮತ್ತು ಓದಲು ಸುಲಭವಾಗುವಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಲು UUIDಗಳ ಕೆಲವು ಮಿತಿಗಳನ್ನು ಪರಿಹರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಯಿತು. ULID ನಿರ್ದಿಷ್ಟತೆ ತನ್ನ ಪರಿಚಯದ ನಂತರ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ, ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಲಭ್ಯವಿರುವ ವಿವಿಧ ಕಾರ್ಯಗತಗೊಳಣೆಗಳೊಂದಿಗೆ.

ಉದಾಹರಣೆಗಳು

ಈಗಾಗಲೇ ULIDs ಅನ್ನು ವಿಭಿನ್ನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ರಚಿಸಲು ಕೆಲವು ಕೋಡ್ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

1// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗತಗೊಳಣೆ
2function generateULID() {
3  const timestamp = Date.now().toString(36).padStart(10, '0');
4  const randomness = crypto.getRandomValues(new Uint8Array(16))
5    .reduce((acc, byte) => acc + byte.toString(36).padStart(2, '0'), '');
6  return (timestamp + randomness).toUpperCase();
7}
8
9console.log(generateULID());
10

1## ಪೈಥಾನ್ ಕಾರ್ಯಗತಗೊಳಣೆ
2import time
3import secrets
4import base64
5
6def generate_ulid():
7    timestamp = int(time.time() * 1000).to_bytes(6, byteorder="big")
8    randomness = secrets.token_bytes(10)
9    return base64.b32encode(timestamp + randomness).decode("ascii").lower()
10
11print(generate_ulid())
12

1// ಜಾವಾ ಕಾರ್ಯಗತಗೊಳಣೆ
2import java.security.SecureRandom;
3import java.time.Instant;
4
5public class ULIDGenerator {
6    private static final SecureRandom random = new SecureRandom();
7    private static final char[] ENCODING_CHARS = "0123456789ABCDEFGHJKMNPQRSTVWXYZ".toCharArray();
8
9    public static String generateULID() {
10        long timestamp = Instant.now().toEpochMilli();
11        byte[] randomness = new byte[10];
12        random.nextBytes(randomness);
13
14        StringBuilder result = new StringBuilder();
15        // ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡಿ
16        for (int i = 9; i >= 0; i--) {
17            result.append(ENCODING_CHARS[(int) (timestamp % 32)]);
18            timestamp /= 32;
19        }
20        // ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡಿ
21        for (byte b : randomness) {
22            result.append(ENCODING_CHARS[b & 31]);
23        }
24        return result.toString();
25    }
26
27    public static void main(String[] args) {
28        System.out.println(generateULID());
29    }
30}
31

ಈ ಉದಾಹರಣೆಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಪೈಥಾನ್ ಮತ್ತು ಜಾವಾದಲ್ಲಿ ULIDs ಅನ್ನು ಹೇಗೆ ರಚಿಸಲು ತೋರಿಸುತ್ತವೆ. ನೀವು ಈ ಕಾರ್ಯಗಳನ್ನು ನಿಮ್ಮ ವಿಶೇಷ ಅಗತ್ಯಗಳಿಗೆ ಹೊಂದಿಸಲು ಅಥವಾ ವಿಶಿಷ್ಟ ಗುರುತಿನ ಸೂಚಕಗಳನ್ನು ಅಗತ್ಯವಿರುವ ದೊಡ್ಡ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಏಕೀಕರಿಸಲು ಹೊಂದಿಸಬಹುದು.

ಉಲ್ಲೇಖಗಳು

1. "ULID ನಿರ್ದಿಷ್ಟತೆ." GitHub, https://github.com/ulid/spec. ಪ್ರವೇಶಿತ 2 ಆಗಸ್ಟ್ 2024.
2. "ಕ್ರಾಕ್‌ಫೋರ್ಡ್‌ನ ಬೇಸ್32 ಎನ್‌ಕೋಡಿಂಗ್." ಬೇಸ್32 ಎನ್‌ಕೋಡಿಂಗ್, http://www.crockford.com/base32.html. ಪ್ರವೇಶಿತ 2 ಆಗಸ್ಟ್ 2024.
3. "UUID ವಿರುದ್ಧ ULID." ಸ್ಟಾಕ್ ಓವರ್ಫ್ಲೋ, https://stackoverflow.com/questions/54222235/uuid-vs-ulid. ಪ್ರವೇಶಿತ 2 ಆಗಸ್ಟ್ 2024.