UUID జనరేటర్

పరిచయం

యూనివర్సలీ యూనిక్ ఐడెంటిఫయర్ (UUID) అనేది కంప్యూటర్ వ్యవస్థలలో సమాచారం గుర్తించడానికి ఉపయోగించే 128-బిట్ సంఖ్య. UUIDలను ఓపెన్ సాఫ్ట్‌వేర్ ఫౌండేషన్ (OSF) ద్వారా డిస్ట్రిబ్యూటెడ్ కంప్యూటింగ్ ఎన్విరాన్‌మెంట్ (DCE) భాగంగా ప్రమాణీకరించబడింది. ఈ గుర్తింపులు స్థలం మరియు సమయం రెండింటిలోనూ ప్రత్యేకంగా ఉండేలా రూపొందించబడ్డాయి, ఇది వాటిని విభజిత వ్యవస్థల మరియు ఇతర అనేక అనువర్తనాల కోసం అనుకూలంగా చేస్తుంది.

ఈ UUID జనరేటర్ టూల్, వెర్షన్ 1 (సమయ ఆధారిత) మరియు వెర్షన్ 4 (యాదృచ్ఛిక) UUIDలను సృష్టించడానికి మీకు అనుమతిస్తుంది. ఈ గుర్తింపులు ప్రత్యేక గుర్తింపు అవసరమయ్యే వివిధ సందర్భాలలో ఉపయోగపడతాయి, ఉదాహరణకు డేటాబేస్ కీలు, విభజిత వ్యవస్థలు మరియు నెట్‌వర్క్ ప్రోటోకాల్‌లు.

UUIDలు ఎలా పనిచేస్తాయి

UUID నిర్మాణం

UUID సాధారణంగా 32 హెక్సాడెసిమల్ అక్షరాలను 5 సమూహాలలో హైఫెన్లతో విడగొట్టి ప్రదర్శించబడుతుంది, మొత్తం 36 అక్షరాలు (32 అక్షరాలు మరియు 4 హైఫెన్లు) కలిగి ఉంటుంది. ఉదాహరణకు:

1550e8400-e29b-41d4-a716-446655440000
2

UUID యొక్క 128 బిట్లు ప్రత్యేకమైన ఫీల్డ్స్‌లో విభజించబడ్డాయి, ప్రతి ఒక్కటి UUID వెర్షన్ ఆధారంగా వివిధ సమాచారాన్ని కలిగి ఉంటుంది:

• 32 బిట్లు time_low ఫీల్డ్ కోసం
• 16 బిట్లు time_mid ఫీల్డ్ కోసం
• 16 బిట్లు time_hi_and_version ఫీల్డ్ కోసం
• 8 బిట్లు clock_seq_hi_and_reserved ఫీల్డ్ కోసం
• 8 బిట్లు clock_seq_low ఫీల్డ్ కోసం
• 48 బిట్లు node ఫీల్డ్ కోసం

UUID నిర్మాణాన్ని చూపించే చిత్రం ఇక్కడ ఉంది:

UUID వెర్షన్లు

UUIDల యొక్క అనేక వెర్షన్లు ఉన్నాయి, ప్రతి ఒక్కటి తనదైన ఉత్పత్తి పద్ధతితో:

1. వెర్షన్ 1 (సమయ ఆధారిత): ప్రస్తుత టైమ్‌స్టాంప్ మరియు కంప్యూటర్ యొక్క MAC చిరునామాను ఉపయోగిస్తుంది.
2. వెర్షన్ 2 (DCE భద్రత): వెర్షన్ 1 కు సమానమైనది, కానీ ఒక స్థానిక డొమైన్ గుర్తింపును కలిగి ఉంటుంది.
3. వెర్షన్ 3 (నామ ఆధారిత, MD5): ఒక నామస్థానం గుర్తింపు మరియు పేరును హాష్ చేయడం ద్వారా ఉత్పత్తి చేయబడుతుంది.
4. వెర్షన్ 4 (యాదృచ్ఛిక): యాదృచ్ఛిక లేదా పseudo-యాదృచ్ఛిక సంఖ్యను ఉపయోగించి ఉత్పత్తి చేయబడుతుంది.
5. వెర్షన్ 5 (నామ ఆధారిత, SHA-1): వెర్షన్ 3 కు సమానమైనది, కానీ SHA-1 హాషింగ్‌ను ఉపయోగిస్తుంది.

ఈ టూల్ వెర్షన్ 1 మరియు వెర్షన్ 4 UUIDలను ఉత్పత్తి చేయడంపై దృష్టి సారిస్తుంది.

ఫార్ములా

వెర్షన్ 1 UUID ఉత్పత్తి

వెర్షన్ 1 UUIDలను క్రింది భాగాలను ఉపయోగించి ఉత్పత్తి చేయబడుతుంది:

1. టైమ్‌స్టాంప్: అక్టోబర్ 15, 1582 (క్రైస్తవ క్యాలెండర్‌కు గ్రెగోరియన్ సంస్కరణ తేదీ) నుండి 100-నానోసెకండ్ అంతరాల సంఖ్యను సూచించే 60-బిట్ విలువ.
2. క్లాక్ సీక్వెన్స్: క్లాక్‌ను వెనక్కు సెట్ చేసిన సందర్భంలో డూప్లికేట్లను నివారించడానికి ఉపయోగించే 14-బిట్ విలువ.
3. నోడ్: సాధారణంగా కంప్యూటర్ యొక్క MAC చిరునామా నుండి ఉత్పత్తి చేయబడే 48-బిట్ విలువ.

వెర్షన్ 1 UUIDను ఉత్పత్తి చేయడానికి ఫార్ములా ఈ విధంగా ఉంటుంది:

1UUID = (timestamp * 2^64) + (clock_sequence * 2^48) + node
2

వెర్షన్ 4 UUID ఉత్పత్తి

వెర్షన్ 4 UUIDలను క్రిప్టోగ్రాఫిక్‌గా బలమైన యాదృచ్ఛిక సంఖ్యా జనరేటర్‌ను ఉపయోగించి ఉత్పత్తి చేయబడుతుంది. ఫార్ములా సులభంగా ఉంటుంది:

1UUID = random_128_bit_number
2

కొన్ని బిట్లు వెర్షన్ (4) మరియు వేరియంట్‌ను సూచించడానికి సెట్ చేయబడ్డాయి.

ఉపయోగాల కేసులు

UUIDలకు కంప్యూటర్ శాస్త్రం మరియు సాఫ్ట్‌వేర్ ఇంజనీరింగ్ యొక్క వివిధ విభాగాలలో అనేక అనువర్తనాలు ఉన్నాయి:

1. డేటాబేస్ కీలు: UUIDలు విభజిత వ్యవస్థలలో, ప్రత్యేకంగా డేటాబేస్‌లలో ప్రాథమిక కీగా తరచుగా ఉపయోగిస్తారు, ప్రత్యేకంగా అనేక నోడ్లు సమకాలికంగా రికార్డులను ఉత్పత్తి చేయవచ్చు.

2. విభజిత వ్యవస్థలు: పెద్ద స్థాయి విభజిత వ్యవస్థలలో, UUIDలు అనేక నోడ్స్ లేదా డేటా కేంద్రాల మధ్య వనరులు, లావాదేవీలు లేదా సంఘటనలను ప్రత్యేకంగా గుర్తించడంలో సహాయపడతాయి.

3. కంటెంట్ అడ్రసింగ్: UUIDలు కంటెంట్ అడ్రసబుల్ స్టోరేజ్ వ్యవస్థలలో ప్రత్యేక గుర్తింపులను సృష్టించడానికి ఉపయోగించవచ్చు.

4. సెషన్ నిర్వహణ: వెబ్ అనువర్తనాలు తరచుగా UUIDలను ఉపయోగించి వినియోగదారు సెషన్లను నిర్వహిస్తాయి, ప్రతి సెషన్‌కు ప్రత్యేక గుర్తింపు కలిగి ఉండాలని నిర్ధారించడానికి.

5. IoT పరికరాల గుర్తింపు: ఇంటర్నెట్ ఆఫ్ థింగ్స్ (IoT) అనువర్తనాలలో, UUIDలు నెట్‌వర్క్‌లో వ్యక్తిగత పరికరాలను ప్రత్యేకంగా గుర్తించడానికి ఉపయోగించవచ్చు.

ప్రత్యామ్నాయాలు

UUIDలు విస్తృతంగా ఉపయోగించబడుతున్నప్పటికీ, ప్రత్యేక గుర్తింపులను ఉత్పత్తి చేయడానికి ప్రత్యామ్నాయ పద్ధతులు ఉన్నాయి:

1. ఆటో-ఇంక్రిమెంటింగ్ IDలు: ఒకే డేటాబేస్ వ్యవస్థలలో సాధారణంగా ఉపయోగించబడే సరళమైనవి, కానీ విభజిత వాతావరణాలకు అనుకూలంగా ఉండవు.

2. టైమ్‌స్టాంప్ ఆధారిత IDలు: సమయ-ఆధారిత డేటా కోసం ఉపయోగకరంగా ఉండవచ్చు కానీ అధిక-సమకాలిక దృశ్యాలలో డూప్లికేషన్ సమస్యలను ఎదుర్కొనవచ్చు.

3. స్నోఫ్లేక్ IDలు: ట్విట్టర్ ద్వారా అభివృద్ధి చేయబడ్డాయి, ఈ IDలు ప్రత్యేకమైన IDలను ఉత్పత్తి చేయడానికి టైమ్‌స్టాంప్ మరియు వర్కర్ సంఖ్యను కలుస్తాయి.

4. ULID (యూనివర్సలీ యూనిక్ లెక్సికోగ్రాఫికల్‌గా సార్టబుల్ ఐడెంటిఫయర్): UUIDల కంటే మానవ-స్నేహపూర్వకంగా మరియు సార్టబుల్‌గా ఉండటానికి లక్ష్యంగా ఉత్పత్తి చేయబడిన తాజా ప్రత్యామ్నాయం.

చరిత్ర

UUIDల యొక్క భావన మొదట అపోలో నెట్‌వర్క్ కంప్యూటింగ్ వ్యవస్థలో ప్రవేశపెట్టబడింది మరియు 1990లలో ఓపెన్ సాఫ్ట్‌వేర్ ఫౌండేషన్ (OSF) ద్వారా ప్రమాణీకరించబడింది. మొదటి స్పెసిఫికేషన్ 1997లో ISO/IEC 11578:1996గా ప్రచురించబడింది మరియు 2005లో ISO/IEC 9834-8:2005 భాగంగా పునరావృతమైంది.

UUID చరిత్రలో కీలక మైలురాళ్లు:

• 1980ల: అపోలో కంప్యూటర్ UUID భావనను వారి నెట్‌వర్క్ కంప్యూటింగ్ వ్యవస్థ కోసం అభివృద్ధి చేస్తుంది.
• 1997: మొదటి UUID స్పెసిఫికేషన్ ISO/IEC 11578:1996గా ప్రచురించబడింది.
• 2005: UUID స్పెసిఫికేషన్ పునరావృతమై ISO/IEC 9834-8:2005 భాగంగా ప్రచురించబడింది.
• 2009: RFC 4122 UUID ఫార్మాట్ మరియు ఈ రోజుల్లో ఉపయోగించే ఉత్పత్తి ఆల్గోరిథాలను నిర్వచిస్తుంది.

కాలక్రమంలో, UUIDలు విభజిత వ్యవస్థలు మరియు డేటాబేస్ డిజైన్‌లో ఒక ముఖ్యమైన సాధనంగా మారాయి, వివిధ ప్రోగ్రామింగ్ భాషలు మరియు ప్లాట్‌ఫారమ్‌లలో వివిధ అమలు మరియు అనుకూలీకరణలతో.

కోడ్ ఉదాహరణలు

ఇక్కడ వివిధ ప్రోగ్రామింగ్ భాషలలో UUIDలను ఉత్పత్తి చేయడానికి ఉదాహరణలు ఉన్నాయి:

1import uuid
2
3## వెర్షన్ 4 (యాదృచ్ఛిక) UUIDని ఉత్పత్తి చేయండి
4random_uuid = uuid.uuid4()
5print(f"వెర్షన్ 4 UUID: {random_uuid}")
6
7## వెర్షన్ 1 (సమయ ఆధారిత) UUIDని ఉత్పత్తి చేయండి
8time_based_uuid = uuid.uuid1()
9print(f"వెర్షన్ 1 UUID: {time_based_uuid}")
10

1const { v1: uuidv1, v4: uuidv4 } = require('uuid');
2
3// వెర్షన్ 4 (యాదృచ్ఛిక) UUIDని ఉత్పత్తి చేయండి
4const randomUuid = uuidv4();
5console.log(`వెర్షన్ 4 UUID: ${randomUuid}`);
6
7// వెర్షన్ 1 (సమయ ఆధారిత) UUIDని ఉత్పత్తి చేయండి
8const timeBasedUuid = uuidv1();
9console.log(`వెర్షన్ 1 UUID: ${timeBasedUuid}`);
10

1import java.util.UUID;
2
3public class UuidGenerator {
4    public static void main(String[] args) {
5        // వెర్షన్ 4 (యాదృచ్ఛిక) UUIDని ఉత్పత్తి చేయండి
6        UUID randomUuid = UUID.randomUUID();
7        System.out.println("వెర్షన్ 4 UUID: " + randomUuid);
8
9        // వెర్షన్ 1 (సమయ ఆధారిత) UUIDని ఉత్పత్తి చేయండి
10        UUID timeBasedUuid = UUID.fromString(new com.eaio.uuid.UUID().toString());
11        System.out.println("వెర్షన్ 1 UUID: " + timeBasedUuid);
12    }
13}
14

1require 'securerandom'
2
3## వెర్షన్ 4 (యాదృచ్ఛిక) UUIDని ఉత్పత్తి చేయండి
4random_uuid = SecureRandom.uuid
5puts "వెర్షన్ 4 UUID: #{random_uuid}"
6
7## రూబీ వెర్షన్ 1 UUIDలకు బిల్ట్-ఇన్ పద్ధతి లేదు
8## మీరు 'uuidtools' వంటి జెమ్‌ను ఉపయోగించాలి
9

1<?php
2// వెర్షన్ 4 (యాదృచ్ఛిక) UUIDని ఉత్పత్తి చేయండి
3$randomUuid = sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
4    mt_rand(0, 0xffff), mt_rand(0, 0xffff),
5    mt_rand(0, 0xffff),
6    mt_rand(0, 0x0fff) | 0x4000,
7    mt_rand(0, 0x3fff) | 0x8000,
8    mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
9);
10echo "వెర్షన్ 4 UUID: " . $randomUuid . "\n";
11
12// PHP వెర్షన్ 1 UUIDలకు బిల్ట్-ఇన్ పద్ధతి లేదు
13// మీరు 'ramsey/uuid' వంటి లైబ్రరీని ఉపయోగించాలి
14?>
15

సూచనలు

1. లీచ్, పి., మీలింగ్, ఎం., & సాల్జ్, ఆర్. (2005). యూనివర్సలీ యూనిక్ ఐడెంటిఫయర్ (UUID) URN నామస్థానం. RFC 4122. https://tools.ietf.org/html/rfc4122
2. అంతర్జాతీయ సంస్థ ప్రమాణీకరణ. (2005). సమాచార సాంకేతికత – ఓపెన్ సిస్టమ్స్ ఇంటర్‌కనెక్షన్ – OSI నమోదు అధికారుల కార్యకలాపాల ప్రక్రియలు: యూనివర్సలీ యూనిక్ ఐడెంటిఫయర్ల (UUID) ఉత్పత్తి మరియు నమోదు మరియు వాటిని ASN.1 ఆబ్జెక్ట్ ఐడెంటిఫయర్ భాగాలుగా ఉపయోగించడం. ISO/IEC 9834-8:2005. https://www.iso.org/standard/62795.html
3. యూనివర్సలీ యూనిక్ ఐడెంటిఫయర్. (2023). వికీపీడియాలో. https://en.wikipedia.org/wiki/Universally_unique_identifier
4. స్నోఫ్లేక్ ID. (2023). వికీపీడియాలో. https://en.wikipedia.org/wiki/Snowflake_ID
5. ULID స్పెసిఫికేషన్. (n.d.). GitHub. https://github.com/ulid/spec