MongoDB ObjectID જનરેટર - યુનિક BSON ઓળખકર્તાઓ બનાવો

MongoDB ObjectID શું છે?

MongoDB ObjectID એ 12-બાઇટનું મૂલ્ય છે, જે MongoDB દરેક દસ્તાવેજના _id ક્ષેત્રને મૂળભૂત રીતે સોંપે છે. તે 24 નાના હેક્સાડેસિમલ અક્ષરો તરીકે લખાય છે, ઉદાહરણ તરીકે 507f1f77bcf86cd799439011. આ સાધન એક સમયે 1 થી 100 માન્ય ObjectID બનાવે છે, સીધા બ્રાઉઝરમાં, ડેટાબેઝ કનેક્શનની જરૂર વગર.

MongoDB ObjectID ની રચના

ObjectID ત્રણ ભાગોથી બને છે, જે એક પછી એક મૂકવામાં આવે છે:

• ટાઇમસ્ટૅમ્પ (4 બાઇટ). 1 જાન્યુઆરી, 1970 (Unix epoch) પછી પસાર થયેલી સેકન્ડોની સંખ્યા, જે સાઇન વિનાની, બિગ-એન્ડિયન સંખ્યા તરીકે સંગ્રહિત થાય છે. તે ObjectID ક્યારે બનાવાયું તે નોંધે છે. ચાર બાઇટમાં 0 થી 4,29,49,67,295 સુધીનાં મૂલ્યો સમાઈ શકે છે, તેથી 7 ફેબ્રુઆરી, 2106 ના 06:28:15 UTC પછી આ ક્ષેત્ર ફરી 0થી શરૂ થાય છે.
• રેન્ડમ મૂલ્ય (5 બાઇટ). પ્રોગ્રામ શરૂ થાય ત્યારે એક વાર રેન્ડમ રીતે પસંદ કરાયેલી સંખ્યા. તે પ્રોગ્રામ ત્યારબાદ બનાવે તે દરેક ObjectID એ જ રેન્ડમ મૂલ્યનો પુનઃઉપયોગ કરે છે, તેથી અલગ કમ્પ્યુટરોને સંકલન કરવાની જરૂર પડતી નથી.
• કાઉન્ટર (3 બાઇટ). 0 અને 1,67,77,215 વચ્ચેના કોઈ રેન્ડમ બિંદુથી શરૂ થતી સંખ્યા, જે દરેક નવા ObjectID માટે 1 જેટલી વધે છે. જો તે 1,67,77,215ને વટાવે, તો ફરી 0થી શરૂ થાય છે.

ભાગોને છેડેથી છેડો જોડ્યા પછી તે આ રીતે દેખાય છે:

1timestamp (8 hex chars) + random value (10 hex chars) + counter (6 hex chars) = 24 hex chars
2

જૂના MongoDB ડ્રાઇવરો મધ્યમ વિભાગને રેન્ડમ સંખ્યાને બદલે મશીન ઓળખકર્તા અને પ્રક્રિયા IDથી બનાવતા હતા. આ સાધન પાછળના તર્ક સહિતના વર્તમાન ડ્રાઇવરો તેના બદલે દરેક પ્રક્રિયા માટે એક રેન્ડમ 5-બાઇટનું મૂલ્ય વાપરે છે.

MongoDB ObjectIDનું ફોર્મેટ અને સૂત્ર

ટકાવારી અથવા વ્યાજની ગણતરીથી વિપરીત, ObjectID પાછળ કોઈ અંકગણિત સૂત્ર નથી. ત્રણ સંખ્યાઓને હેક્સાડેસિમલ લખાણમાં રૂપાંતરિત કરીને અને છેડેથી છેડો જોડીને તે બનાવવામાં આવે છે:

1. Unix epoch પછીની સેકન્ડોમાં વર્તમાન સમય લો અને તેને 0 થી 4,29,49,67,295ની શ્રેણીમાં લાવો, જેથી તે ચાર બાઇટમાં સમાઈ શકે. તેને 8-અંકની હેક્સાડેસિમલ સંખ્યા તરીકે લખો.
2. પ્રક્રિયાના સ્થિર રેન્ડમ મૂલ્યને લો, જે 0થી 2^40 − 1 સુધીની સંખ્યા છે. તેને 10-અંકની હેક્સાડેસિમલ સંખ્યા તરીકે લખો.
3. કાઉન્ટરનું વર્તમાન મૂલ્ય લો, જે 0થી 1,67,77,215 સુધીનું હોય છે. તેને 6-અંકની હેક્સાડેસિમલ સંખ્યા તરીકે લખો, પછી આગામી ID માટે કાઉન્ટરમાં 1નો વધારો કરો.
4. ત્રણેય હેક્સાડેસિમલ સ્ટ્રિંગને એ જ ક્રમમાં જોડીને 24 અક્ષરો ધરાવતી એક સ્ટ્રિંગ બનાવો.

ઉદાહરણ સાથે ગણતરી

ધારો કે કોઈ પ્રોગ્રામ Unix સમય 1,70,00,00,000 સેકન્ડે શરૂ થાય છે, જે 14 નવેમ્બર, 2023ના 22:13:20 UTC સમયને દર્શાવે છે. તે રેન્ડમ મૂલ્ય 3f2a91c8d4 પસંદ કરે છે અને કાઉન્ટર 12,345થી શરૂ કરે છે.

• હેક્સમાં ટાઇમસ્ટૅમ્પ: 6553f100
• હેક્સમાં રેન્ડમ મૂલ્ય: 3f2a91c8d4
• હેક્સમાં કાઉન્ટર: 003039

આ ત્રણેયને જોડવાથી પ્રથમ ObjectID મળે છે:

6553f1003f2a91c8d4003039

જો પ્રોગ્રામ એ જ સેકન્ડમાં બીજું ObjectID બનાવે, તો ટાઇમસ્ટૅમ્પ અને રેન્ડમ મૂલ્ય સમાન રહે છે, પરંતુ કાઉન્ટર વધીને 12,346 (00303a) થાય છે:

6553f1003f2a91c8d400303a

ObjectID વાંચવાનું પણ વિપરીત રીતે થઈ શકે છે. 507f1f77bcf86cd799439011 આપવામાં આવે ત્યારે તેના પ્રથમ 8 અક્ષરો, 507f1f77, epoch પછીની 1,35,05,08,407 સેકન્ડમાં ડિકોડ થાય છે, જે 17 ઑક્ટોબર, 2012ના 21:13:27 UTC સમયને દર્શાવે છે.

MongoDB ObjectID ના સામાન્ય ઉપયોગો

• પ્રાથમિક કીઓ. અલગ મૂલ્ય આપવામાં ન આવે ત્યાં સુધી MongoDB દસ્તાવેજના _id ક્ષેત્રમાં ObjectID આપમેળે મૂકે છે.
• બનાવટના સમયની શોધ. ટાઇમસ્ટૅમ્પ અંદર સમાવાયેલ હોવાથી, અલગ તારીખ ક્ષેત્ર વિના પ્રોગ્રામ દસ્તાવેજનો અંદાજિત બનાવટ સમય વાંચી શકે છે.
• દાખલ ક્રમ પ્રમાણે ગોઠવણી. _id પ્રમાણે દસ્તાવેજોને ગોઠવવાથી તેઓ આશરે બનાવટ સમયના ક્રમમાં ગોઠવાય છે, કારણ કે મૂલ્યમાં ટાઇમસ્ટૅમ્પ સૌપ્રથમ આવે છે.
• પરીક્ષણ અને નમૂના ડેટા. ડેવલપર ડેટાબેઝ ચલાવ્યા વિના નમૂનાના દસ્તાવેજો અથવા સ્વચાલિત પરીક્ષણો બનાવવા જનરેટ કરેલા ObjectID નો ઉપયોગ કરે છે.

MongoDB ObjectID અને UUID વચ્ચેનો તફાવત

UUID (Universally Unique Identifier) એ 16-બાઇટનું મૂલ્ય છે, જે ObjectID કરતાં ચાર બાઇટ મોટું છે. પ્રમાણભૂત UUID સામાન્ય રીતે સમગ્ર રીતે રેન્ડમ હોય છે, તેથી તે બનાવટ સમય દર્શાવતું નથી કે બનાવટના ક્રમમાં ગોઠવાતું નથી. ObjectID નાનું અને આશરે સમયક્રમબદ્ધ હોય છે; MongoDB તેને મૂળભૂત રીતે વાપરે છે તેનું આ એક કારણ છે, જોકે યોગ્ય રીતે જનરેટ કરેલા UUID જેટલી ઔપચારિક અનન્યતાની ખાતરી ObjectID આપતું નથી.

વારંવાર પૂછાતા પ્રશ્નો

MongoDB ObjectID નો ઉપયોગ શા માટે થાય છે? તે મૂળભૂત મૂલ્ય છે, જે MongoDB દસ્તાવેજના _id ક્ષેત્રમાં મૂકે છે, તેથી વધારાની ગોઠવણી વિના દરેક દસ્તાવેજને અનન્ય કી મળે છે.

શું MongoDB ObjectID અનન્ય હોવાની ખાતરી ધરાવે છે? ઔપચારિક, ગણિતીય અર્થમાં નહીં, પરંતુ અથડામણની સંભાવના અત્યંત ઓછી છે. બે ObjectID માટે એ જ સેકન્ડમાં સમાન રેન્ડમ મૂલ્ય અને સમાન કાઉન્ટર સ્થિતિ જરૂરી બને, જે સામાન્ય રીતે એક જ પ્રક્રિયામાં જ બને છે.

શું ObjectID પરથી બનાવટ તારીખ વાંચી શકાય છે? હા. પ્રથમ 8 હેક્સાડેસિમલ અક્ષરો, એટલે કે 4 બાઇટ, Unix epoch પછીની સેકન્ડોની સંખ્યા ધરાવે છે. આ સંખ્યાને તારીખમાં રૂપાંતરિત કરવાથી અંદાજિત બનાવટ સમય મળે છે.

આ જનરેટર એકસાથે કેટલા ObjectID બનાવી શકે છે? દર બેચમાં 1 થી 100 સુધી. બેચમાંના દરેક IDમાં સમગ્ર પ્રક્રિયા માટેનું સમાન રેન્ડમ મૂલ્ય હોય છે અને દરેકનું કાઉન્ટર અગાઉના કરતાં એક વધારે હોય છે.

શું MongoDB ObjectID નો ઉપયોગ MongoDBની બહાર કરી શકાય છે? હા. તે હેક્સાડેસિમલ લખાણ તરીકે એન્કોડ કરેલી માત્ર 12-બાઇટની કિંમતો હોવાથી, અન્ય સિસ્ટમોમાં પણ અનન્ય ID તરીકે કામ કરે છે, જોકે ડેટાબેઝની પોતાની ID યોજના તેની જરૂરિયાતોને વધુ સારી રીતે અનુરૂપ હોઈ શકે છે.

શું આ જનરેટર વાસ્તવિક MongoDB ડેટાબેઝ સાથે જોડાયેલું છે? ના. તે સંપૂર્ણપણે બ્રાઉઝરમાં ચાલે છે અને કોઈ ડેટાબેઝમાંથી વાંચતું કે તેમાં લખતું નથી.

સંદર્ભસૂચિ

1. "ObjectId." MongoDB મેન્યુઅલ, https://www.mongodb.com/docs/manual/reference/method/ObjectId/.
2. "ObjectId Specification." MongoDB BSON વિશિષ્ટતાઓ, https://github.com/mongodb/specifications/blob/master/source/bson-objectid/objectid.md.
3. "BSON Types." BSON વિશિષ્ટતા, https://bsonspec.org/spec.html.