Possibilité de dupliquer les Mongo ObjectId générés dans deux collections différentes?

Est-il possible que le même Mongo ObjectId exact soit généré pour un document dans deux collections différentes? Je me rends compte que c'est vraiment très improbable, mais est-ce possible?

Sans être trop précis, la raison pour laquelle je pose la question est qu'avec une application sur laquelle je travaille, nous montrons des profils publics d'élus que nous espérons convertir en utilisateurs à part entière de notre site. Nous avons des collections séparées pour les utilisateurs et les élus qui ne sont pas actuellement membres de notre site. Il existe divers autres documents contenant diverses données sur les élus qui sont tous renvoyés à la personne utilisant leur ObjectId élu.

Après avoir créé le compte, nous mettons toujours en évidence les données associées à l'élu, mais elles font désormais également partie de la collection d'utilisateurs avec un ObjectId d'utilisateurs correspondant pour mapper leur profil aux interactions avec notre application.

Nous avions commencé à convertir notre application de MySql à Mongo il y a quelques mois et pendant la transition, nous stockons l'ancien identifiant MySql pour ces deux types de données et nous commençons également à stocker le Mongo ObjectId officiel élu dans les utilisateurs. document à renvoyer aux données des élus.

Je réfléchissais simplement à la spécification du nouvel utilisateur ObjectId en tant qu'ObjectId officiel élu précédent pour simplifier les choses, mais je voulais m'assurer qu'il n'était pas possible d'avoir une collision avec un ObjectId utilisateur existant.

Merci pour votre perspicacité.

Edit: Peu de temps après avoir posté cette question, j'ai réalisé que ma solution proposée n'était pas une très bonne idée. Il serait préférable de conserver le schéma actuel que nous avons en place et de le lier simplement au représentant élu '_id' dans le document des utilisateurs.

Réponse courte

Juste pour ajouter une réponse directe à votre question initiale: OUI, si vous utilisez la génération d'ID d'objet BSON, alors pour la plupart des pilotes, les ID seront presque certainement uniques dans les collections. Voir ci-dessous ce que signifie «presque certainement».

Longue réponse

Les ID d'objet BSON générés par les pilotes Mongo DB sont très probablement uniques dans les collections. Ceci est principalement dû aux 3 derniers octets de l'ID, qui pour la plupart des pilotes est généré via un compteur incrémentiel statique. Ce compteur est indépendant de la collection; c'est mondial. Le pilote Java, par exemple, utilise un AtomicInteger statique initialisé de manière aléatoire.

Alors pourquoi, dans la documentation Mongo, disent-ils que les identifiants sont "hautement susceptibles" d'être uniques, au lieu de dire carrément qu'ils seront uniques? Trois possibilités peuvent se produire où vous n'obtiendrez pas un identifiant unique (veuillez me le faire savoir s'il y en a plus):

Avant cette discussion, rappelez-vous que l'ID d'objet BSON se compose de:

[4 octets secondes depuis l'époque, 3 octets de hachage machine, 2 octets d'ID de processus, 3 octets de compteur]

Voici les trois possibilités, vous jugez donc par vous-même de la probabilité d'être dupe:

1) Dépassement du compteur: il y a 3 octets dans le compteur. Si vous insérez plus de 16 777 216 (2 ^ 24) documents en une seule seconde, sur la même machine, dans le même processus, vous pouvez alors déborder les octets du compteur incrémentiel et vous retrouver avec deux ID d'objet qui partagent le même , processus et valeurs de compteur.

2) Compteur non incrémenté: certains pilotes Mongo utilisent des nombres aléatoires au lieu d'incrémenter des nombres pour les octets du compteur. Dans ces cas, il y a une chance de 1/16 777 216 de générer un identifiant non unique, mais seulement si ces deux identifiants sont générés dans la même seconde (c'est-à-dire avant que la section temporelle de l'identifiant ne passe à la seconde suivante), sur le même machine, dans le même processus.

3) Machine et processus de hachage aux mêmes valeurs. Les valeurs d'ID d'ordinateur et d'ID de processus peuvent, dans un scénario hautement improbable, correspondre aux mêmes valeurs pour deux ordinateurs différents. Si cela se produit, et en même temps les deux compteurs sur les deux machines différentes, pendant la même seconde, génèrent la même valeur, alors vous vous retrouverez avec un ID en double.

Ce sont les trois scénarios à surveiller. Les scénarios 1 et 3 semblent hautement improbables, et le scénario 2 est totalement évitable si vous utilisez le bon pilote. Vous devrez vérifier la source du pilote pour en être sûr.

Les ObjectIds sont générés côté client d'une manière similaire à l'UUID, mais avec des propriétés plus intéressantes pour le stockage dans une base de données, telles qu'une augmentation grossière de l'ordre et le codage de leur temps de création gratuitement. L'essentiel pour votre cas d'utilisation est qu'ils sont conçus pour garantir l'unicité à une probabilité élevée même s'ils sont générés sur des machines différentes.

Maintenant, si vous faisiez référence au champ _id en général, nous n'avons pas besoin d'unicité entre les collections, il est donc prudent de réutiliser l'ancien _id. À titre d'exemple concret, si vous avez deux collections, colorset fruits, les deux pourraient avoir simultanément un objet comme {_id: 'orange'}.

Si vous souhaitez en savoir plus sur la création des ObjectIds, voici la spécification: http://www.mongodb.org/display/DOCS/Object+IDs#ObjectIDs-BSONObjectIDSpecification

Au cas où quelqu'un aurait des problèmes avec des ObjectID Mongo dupliqués, vous devez savoir que malgré l'improbabilité que des doublons se produisent dans Mongo lui-même, il est possible d'avoir des _id dupliqués générés avec PHP dans Mongo.

Le cas d'utilisation où cela s'est produit avec régularité pour moi est lorsque je parcours un ensemble de données et que je tente d'injecter les données dans une collection.

Le tableau qui contient les données d'injection doit être explicitement réinitialisé à chaque itération, même si vous ne spécifiez pas la valeur _id. Pour une raison quelconque, le processus INSERT ajoute le Mongo _id au tableau comme s'il s'agissait d'une variable globale (même si le tableau n'a pas de portée globale). Cela peut vous affecter même si vous appelez l'insertion dans un appel de fonction distinct où vous vous attendriez normalement à ce que les valeurs du tableau ne persistent pas dans la fonction appelante.

Il existe trois solutions à cela:

1. Vous pouvez unset()le champ _id du tableau
2. Vous pouvez réinitialiser l'ensemble du tableau à array()chaque fois que vous parcourez votre ensemble de données
3. Vous pouvez définir explicitement la valeur _id vous-même (en prenant soin de la définir de manière à ne pas générer de dups vous-même).

Je suppose que c'est un bogue dans l'interface PHP, et pas tellement un problème avec Mongo, mais si vous rencontrez ce problème, désactivez simplement le _id et tout devrait bien se passer.

Il n'y a aucune garantie sur l'unicité d'ObjectId dans les collections. Même si c'est probablement très improbable, il s'agirait d'une conception d'application très médiocre qui reposerait sur l'unicité de _id dans les collections.

On peut facilement tester cela dans le shell mongo:

MongoDB shell version: 1.6.5
connecting to: test
> db.foo.insert({_id: 'abc'})
> db.bar.insert({_id: 'abc'})
> db.foo.find({_id: 'abc'})
{ "_id" : "abc" }
> db.bar.find({_id: 'abc'})
{ "_id" : "abc" }
> db.foo.insert({_id: 'abc', data:'xyz'})
E11000 duplicate key error index: test.foo.$_id_  dup key: { : "abc" }

Donc, ne comptez absolument pas sur le fait que _id est unique dans les collections, et comme vous ne contrôlez pas la fonction de génération ObjectId, ne vous y fiez pas.

Il est possible de créer quelque chose qui ressemble plus à un uuid, et si vous le faites manuellement, vous pourriez avoir une meilleure garantie d'unicité.

N'oubliez pas que vous pouvez mettre des objets de "types" différents dans la même collection, alors pourquoi ne pas simplement mettre vos deux "tables" dans la même collection. Ils partageraient le même espace _id, et seraient donc garantis uniques. Passer de "prospectif" à "enregistré" serait un simple retournement d'un champ ...