MongoDB ObjectID ಜನಕ

ಪರಿಚಯ

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 2009 ರಲ್ಲಿ MongoDB ಯ ಪ್ರಾಥಮಿಕ ಬಿಡುಗಡೆಗೆ ಪರಿಚಯಿಸಲಾಯಿತು. ವಿಭಜಿತ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಸೂಕ್ತವಾಗಿರುವಂತೆ, ವಿಭಿನ್ನ ಸರ್ವರ್‌ಗಳಿಂದ ಶೀಘ್ರವಾಗಿ ಮತ್ತು ಸ್ವಾಯತ್ತವಾಗಿ ಉತ್ಪಾದಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ವಿಶಿಷ್ಟ ಗುರುತಿನ ಚಿಹ್ನೆ ಒದಗಿಸಲು ಇವು ರೂಪಿಸಲಾಯಿತು.

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 ರಂದು ಪ್ರವೇಶಿಸಲಾಗಿದೆ.