MongoDB ObjectID Generator

ਜਾਣ-ਪਛਾਣ

MongoDB ObjectID ਇੱਕ ਵਿਲੱਖਣ ਪਛਾਣਕਾਰ ਹੈ ਜੋ MongoDB ਡੇਟਾਬੇਸ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਟੂਲ ਤੁਹਾਨੂੰ ਟੈਸਟਿੰਗ, ਵਿਕਾਸ, ਜਾਂ ਸਿੱਖਿਆ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਵੈਧ MongoDB ObjectIDs ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ObjectIDs 12-ਬਾਈਟ ਦੇ BSON ਕਿਸਮਾਂ ਹਨ, ਜੋ 4-ਬਾਈਟ ਦੇ ਟਾਈਮਸਟੈਂਪ, 5-ਬਾਈਟ ਦੇ ਰੈਂਡਮ ਮੁੱਲ, ਅਤੇ 3-ਬਾਈਟ ਦੇ ਵਧਦੇ ਕਾਊਂਟਰ ਤੋਂ ਬਣੇ ਹੁੰਦੇ ਹਨ।

ਇਸ ਜਨਰੇਟਰ ਨੂੰ ਵਰਤਣ ਦਾ ਤਰੀਕਾ

1. ਉਹ ObjectIDs ਦੀ ਸੰਖਿਆ ਦਾਖਲ ਕਰੋ ਜੋ ਤੁਸੀਂ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ (1 ਤੋਂ 100 ਦੇ ਵਿਚਕਾਰ)।
2. ObjectIDs ਬਣਾਉਣ ਲਈ "ਜਨਰੇਟ" ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
3. ਬਣਾਈਆਂ ਗਈਆਂ ObjectIDs ਨੂੰ ਦਿਖਾਇਆ ਜਾਵੇਗਾ, ਨਾਲ ਹੀ ਉਨ੍ਹਾਂ ਦੀ ਬਣਤਰ ਦੀ ਦ੍ਰਿਸ਼ਟੀਕੋਣ।
4. ਤੁਸੀਂ "ਕਾਪੀ ਨਤੀਜਾ" ਬਟਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਈਆਂ ਗਈਆਂ ObjectIDs ਨੂੰ ਆਪਣੇ ਕਲਿੱਪਬੋਰਡ 'ਤੇ ਕਾਪੀ ਕਰ ਸਕਦੇ ਹੋ।

MongoDB ObjectID ਦੀ ਬਣਤਰ

MongoDB ObjectID ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ:

1. ਯੂਨਿਕਸ ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਡਾਂ ਦਾ 4-ਬਾਈਟ ਦਾ ਮੁੱਲ
2. 5-ਬਾਈਟ ਦਾ ਰੈਂਡਮ ਮੁੱਲ
3. ਇੱਕ 3-ਬਾਈਟ ਦਾ ਵਧਦਾ ਕਾਊਂਟਰ, ਜੋ ਇੱਕ ਰੈਂਡਮ ਮੁੱਲ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ

ਇਸ ਬਣਤਰ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਤਰੀਕੇ ਨਾਲ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

1|---- ਟਾਈਮਸਟੈਂਪ -----|-- ਰੈਂਡਮ --|-- ਕਾਊਂਟਰ -|
2   4 ਬਾਈਟ              5 ਬਾਈਟ       3 ਬਾਈਟ
3

ਫਾਰਮੂਲਾ

ਜਦੋਂ ਕਿ ObjectIDs ਬਣਾਉਣ ਲਈ ਕੋਈ ਗਣਿਤੀ ਫਾਰਮੂਲਾ ਨਹੀਂ ਹੈ, ਪਰ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਅਲਗੋਰਿਦਮਿਕ ਤਰੀਕੇ ਨਾਲ ਵਰਣਨ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

1. ਵਰਤਮਾਨ ਟਾਈਮਸਟੈਂਪ (ਯੂਨਿਕਸ ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਦੇ ਸਕਿੰਡ) ਪ੍ਰਾਪਤ ਕਰੋ
2. 5-ਬਾਈਟ ਦਾ ਰੈਂਡਮ ਮੁੱਲ ਬਣਾਓ
3. ਇੱਕ 3-ਬਾਈਟ ਦਾ ਕਾਊਂਟਰ ਇੱਕ ਰੈਂਡਮ ਮੁੱਲ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ
4. ਇਹਨਾਂ ਕੰਪੋਨੈਂਟਸ ਨੂੰ ਜੋੜ ਕੇ 12-ਬਾਈਟ ਦਾ ObjectID ਬਣਾਓ

ਜਨਰੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ

ObjectID ਜਨਰੇਟਰ ਹੇਠਾਂ ਦਿੱਤੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ:

1. ਵਰਤਮਾਨ ਯੂਨਿਕਸ ਟਾਈਮਸਟੈਂਪ ਨੂੰ 4-ਬਾਈਟ ਦੇ ਹੈਕਸਾਡੇ ਮੁੱਲ ਵਿੱਚ ਬਦਲੋ
2. 5 ਰੈਂਡਮ ਬਾਈਟ ਬਣਾਓ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਹੈਕਸਾਡੇ ਵਿੱਚ ਬਦਲੋ
3. ਇੱਕ ਰੈਂਡਮ 3-ਬਾਈਟ ਕਾਊਂਟਰ ਬਣਾਓ ਅਤੇ ਉਸਨੂੰ ਹੈਕਸਾਡੇ ਵਿੱਚ ਬਦਲੋ
4. ਇਹ ਤਿੰਨ ਕੰਪੋਨੈਂਟਸ ਨੂੰ ਜੋੜ ਕੇ 24-ਅੱਖਰਾਂ ਦਾ ਹੈਕਸਾਡੇ ਸਟਰਿੰਗ ਬਣਾਓ

ਵਰਤੋਂ ਦੇ ਕੇਸ

MongoDB ObjectIDs ਦੇ ਕਈ ਮਹੱਤਵਪੂਰਨ ਵਰਤੋਂ ਦੇ ਕੇਸ ਹਨ:

1. ਵਿਲੱਖਣ ਦਸਤਾਵੇਜ਼ ਪਛਾਣਕਾਰ: ObjectIDs MongoDB ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਡਿਫਾਲਟ _id ਖੇਤਰ ਦੇ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ, ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਹਰ ਦਸਤਾਵੇਜ਼ ਦਾ ਇੱਕ ਵਿਲੱਖਣ ਪਛਾਣਕਾਰ ਹੈ।

2. ਟਾਈਮਸਟੈਂਪ ਜਾਣਕਾਰੀ: ObjectID ਦੇ ਪਹਿਲੇ 4 ਬਾਈਟ ਇੱਕ ਟਾਈਮਸਟੈਂਪ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਇਕ ਵੱਖਰਾ ਖੇਤਰ ਬਣਾਉਣ ਦੀ ਲੋੜ ਦੇ ਬਿਨਾਂ ਬਣਾਉਣ ਦੇ ਸਮੇਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

3. ਸੋਰਟਿੰਗ: ObjectIDs ਨੂੰ ਕ੍ਰਮਵਾਰ ਤੌਰ 'ਤੇ ਸੋਰਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੇ ਆਰਡਰ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹੈ।

4. ਸ਼ਾਰਡਿੰਗ: ਇੱਕ ਸ਼ਾਰਡਡ MongoDB ਕਲੱਸਟਰ ਵਿੱਚ, ObjectIDs ਨੂੰ ਸ਼ਾਰਡ ਕੁੰਜੀਆਂ ਦੇ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਹਰ ਵਰਤੋਂ ਦੇ ਕੇਸ ਲਈ ਸਹੀ ਚੋਣ ਨਹੀਂ ਹੋ ਸਕਦੀ।

5. ਡਿਬੱਗਿੰਗ ਅਤੇ ਲੌਗਿੰਗ: ObjectIDs ਦੇ ਟਾਈਮਸਟੈਂਪ ਭਾਗ ਨੂੰ ਡਿਬੱਗਿੰਗ ਅਤੇ ਲੌਗ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ।

ਵਿਕਲਪ

ਜਦੋਂ ਕਿ ObjectIDs MongoDB ਵਿੱਚ ਡਿਫਾਲਟ ਪਛਾਣਕਾਰ ਹਨ, ਕੁਝ ਵਿਕਲਪ ਹਨ:

1. ਕੁਦਰਤੀ ਪਛਾਣਕਾਰ: ਆਪਣੇ ਡੇਟਾ ਤੋਂ ਇੱਕ ਕੁਦਰਤੀ ਵਿਲੱਖਣ ਪਛਾਣਕਾਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ (ਜਿਵੇਂ ਕਿ ਈਮੇਲ ਪਤਾ, ISBN)
2. ਆਟੋ-ਇੰਕ੍ਰਿਮੈਂਟਿੰਗ ਨੰਬਰ: ਪਰੰਪਰਾਗਤ RDBMS ਆਟੋ-ਇੰਕ੍ਰਿਮੈਂਟਿੰਗ ਪ੍ਰਾਈਮਰੀ ਕੁੰਜੀਆਂ ਦੀ ਤਰ੍ਹਾਂ
3. UUIDs: ਵਿਸ਼ਵਵਿਆਪੀ ਵਿਲੱਖਣ ਪਛਾਣਕਾਰ, ਜੋ 128-ਬਾਈਟ ਦੇ ਪਛਾਣਕਾਰ ਹਨ
4. ਕਸਟਮ ਜਨਰੇਸ਼ਨ ਸਕੀਮਾਂ: ਆਪਣੇ ਵਿਸ਼ੇਸ਼ ਜਰੂਰਤਾਂ ਦੇ ਲਈ ਆਪਣੀ ID ਜਨਰੇਸ਼ਨ ਤਰਤੀਬ ਬਣਾਉਣਾ

ਇਤਿਹਾਸ

ObjectIDs MongoDB ਦੇ ਸ਼ੁਰੂਆਤੀ ਰਿਲੀਜ਼ ਦੇ ਨਾਲ 2009 ਵਿੱਚ ਜਾਣਕਾਰੀ ਦਿੱਤੀ ਗਈ ਸੀ। ਇਹ ਇੱਕ ਵਿਲੱਖਣ ਪਛਾਣਕਾਰ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤੇ ਗਏ ਜੋ ਵੱਖ-ਵੱਖ ਸਰਵਰਾਂ ਦੁਆਰਾ ਤੇਜ਼ੀ ਨਾਲ ਅਤੇ ਸੁਤੰਤਰਤਾ ਨਾਲ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਇਹ ਵੰਡਿਤ ਪ੍ਰਣਾਲੀਆਂ ਲਈ ਆਦਰਸ਼ ਬਣਦਾ ਹੈ।

ObjectIDs ਦੀ ਬਣਤਰ MongoDB ਦੇ ਇਤਿਹਾਸ ਦੌਰਾਨ ਸਥਿਰ ਰਹੀ ਹੈ, ਹਾਲਾਂਕਿ ਇਹਨਾਂ ਦੇ ਬਣਨ ਦੀ ਵਿਸ਼ੇਸ਼ ਕਾਰਵਾਈ ਨੂੰ ਸਮੇਂ ਦੇ ਨਾਲ ਸੁਧਾਰਿਆ ਗਿਆ ਹੈ।

ਉਦਾਹਰਣਾਂ

ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੇ ਟੁਕੜੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ MongoDB ObjectIDs ਬਣਾਉਣ ਦਾ ਤਰੀਕਾ ਦਰਸਾਉਂਦੇ ਹਨ:

1import bson
2
3## ਇੱਕ ObjectID ਬਣਾਓ
4object_id = bson.ObjectId()
5print(object_id)
6
7## ਬਹੁਤ ਸਾਰੇ ObjectIDs ਬਣਾਓ
8object_ids = [bson.ObjectId() for _ in range(5)]
9print(object_ids)
10

1const { ObjectId } = require('mongodb');
2
3// ਇੱਕ ObjectID ਬਣਾਓ
4const objectId = new ObjectId();
5console.log(objectId.toString());
6
7// ਬਹੁਤ ਸਾਰੇ ObjectIDs ਬਣਾਓ
8const objectIds = Array.from({ length: 5 }, () => new ObjectId().toString());
9console.log(objectIds);
10

1import org.bson.types.ObjectId;
2
3public class ObjectIdExample {
4    public static void main(String[] args) {
5        // ਇੱਕ ObjectID ਬਣਾਓ
6        ObjectId objectId = new ObjectId();
7        System.out.println(objectId.toString());
8
9        // ਬਹੁਤ ਸਾਰੇ ObjectIDs ਬਣਾਓ
10        for (int i = 0; i < 5; i++) {
11            System.out.println(new ObjectId().toString());
12        }
13    }
14}
15

1require 'bson'
2
3## ਇੱਕ ObjectID ਬਣਾਓ
4object_id = BSON::ObjectId.new
5puts object_id.to_s
6
7## ਬਹੁਤ ਸਾਰੇ ObjectIDs ਬਣਾਓ
8object_ids = 5.times.map { BSON::ObjectId.new.to_s }
9puts object_ids
10

ਇਹ ਉਦਾਹਰਣਾਂ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਅਧਿਕਾਰਤ MongoDB ਡਰਾਈਵਰ ਜਾਂ BSON ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ObjectIDs ਬਣਾਉਣ ਦਾ ਤਰੀਕਾ ਦਰਸਾਉਂਦੀਆਂ ਹਨ। ਬਣਾਈਆਂ ਗਈਆਂ ObjectIDs ਵਿਲੱਖਣ ਹੋਣਗੀਆਂ ਅਤੇ ਉੱਪਰ ਦਿੱਤੀ ਗਈ ਬਣਤਰ ਦਾ ਪਾਲਣ ਕਰਨਗੀਆਂ।

ਹਵਾਲੇ

1. "ObjectId." MongoDB ਮੈਨੂਅਲ, https://docs.mongodb.com/manual/reference/method/ObjectId/. ਪਹੁੰਚਿਆ 2 ਅਗਸਤ 2024।
2. "BSON ਕਿਸਮਾਂ." BSON ਵਿਸ਼ੇਸ਼ਤਾ, http://bsonspec.org/spec.html. ਪਹੁੰਚਿਆ 2 ਅਗਸਤ 2024।
3. "MongoDB ObjectID." ਵਿਕੀਪੀਡੀਆ, ਵਿੱਕੀਮੀਡੀਆ ਫਾਉਂਡੇਸ਼ਨ, https://en.wikipedia.org/wiki/ObjectId. ਪਹੁੰਚਿਆ 2 ਅਗਸਤ 2024।