Edit Report a Bug

    MongoCollection::insert

    (PECL mongo >=0.9.0)

    MongoCollection::insert — Insère un document dans la collection

    Description

    public MongoCollection::insert ( array|object $document [, array $options = array() ] ) : bool|array

    Toutes les chaînes envoyées à la base de données doivent être en UTF-8. Si une chaîne n'est pas UTF-8, une exception MongoException sera émise. Pour insérer (ou chercher) une chaîne non-UTF-8, utilisez la méthode MongoBinData.

    Liste de paramètres

    document

    Un tableau ou un objet. Si un objet est utilisé, ses propriétés ne doivent être ni protégées, ni privées.

    Note:

    Si le paramètre n'a pas de clé _id ou de propriété, une nouvelle instance MongoId sera créée et utilisée. Ce comportement spécial ne signifie pas que le paramètre est passé par référence.

    options

    Un tableau d'options pour l'opération d'insertion. Les options actuellement disponibles sont :

    • "fsync"

      Booléen, par défaut à FALSE. Si l'historisation est activée, il fonctionne exactement comme "j". Si l'historisation n'est pas activée, l'opération en écriture sera bloquante tant qu'elle ne sera pas synchronisé sur les fichiers de base de données du disque. Si vaut TRUE, une insertion reconnue devient implicite, et cette option va écraser la configuration "w" à 0.

      Note: Si l'historisation est activée, les utilisateurs sont vivement encouragés à utiliser l'option "j" au lieu de "fsync". N'utilisez pas "fsync" et "j" en même temps, ou une erreur sera produite.

    • "j"

      Booléen, par défaut à FALSE. Force les opérations en écriture a être bloquantes tant qu'elles ne sont pas synchronisées dans le journal du disque. Si vaut TRUE, une écriture reconnue est implicite, et cette option va écraser la configuration "w" à 0.

      Note: Si cette option est utilisée, et que l'historisation est désactivée, MongoDB 2.6+ va lancer une erreur, et l'écriture échouera ; les anciennes versions du serveur vont simplement ignorer cette ooption.

    • "socketTimeoutMS"

      Cette option spécifie la durée limite, en millisecondes, pour la communication avec un socket. Si le serveur ne répond pas pendant cette période, une exception MongoCursorTimeoutException sera émise et il n'y a aucune façon de déterminer si le serveur gère actuellement l'écriture ou non. Une valeur de -1 peut être spécifiée pour bloquer indéfiniement. La valeur par défaut pour MongoClient est 30000 (30 secondes).

    • "w"

      Voir les préoccupatios d'écriture. La valeur par défaut pour MongoClient est 1.

    • "wTimeoutMS"

      Cette option spécifie la durée limite, en millisecondes, pour la reconnaissance des préoccupations d'écriture.Ceci n'est applicable que lorsque "w" est supérieur à 1, sachant que le délai d'attente maximal est en relation avec la réplication. Si la préoccupation d'écriture n'est pas spécifiée dans la durée limite, une exception MongoCursorException sera émise. Une valeur de 0 peut être spécifiée pour un blocage permanent. La valeur par défaut pour MongoClient est 10000 (dix secondes).

    Les options suivantes sont obsolètes, et ne devraient plus être utilisées :

    • "safe"

      Deprecated. Please use the write concern "w" option.

    • "timeout"

      Alias obsolète pour "socketTimeoutMS".

    • "wtimeout"

      Alias obsolète pour "wTimeoutMS".

    Valeurs de retour

    Retourne un tableau contenant le statut de l'insertion si l'option "w" est définie. Sinon, retourne TRUE si le tableau inséré n'est pas vide (une exception MongoException sera lancée si le tableau inséré est vide).

    Si un tableau est retourné, les clés suivantes peuvent être présentes :

    ok

    Doit toujours valoir 1 (à moins que last_error échoue).

    err

    Si ce champ est non-nul, une erreur est survenue lors de la dernière opération. Si ce champ est défini, il sera une chaîne de caractères décrivant l'erreur survenue.

    code

    Si une erreur de base de données est survenue, le code erreur de cette erreur sera passé au client.

    errmsg

    Ce champ est défini si quelque chose a échoué avec une commande de base de données. Il est couplé avec ok qui vaudra alors 0. Par exemple, si w est défini et que le délai maximal d'attente est atteint, errmsg sera défini à "timed out waiting for slaves" et ok vaudra 0. Si ce champ est défini, il sera une chaîne de caractères décrivant l'erreur survenue.

    n

    Si la dernière opération était une mise à jour, un upsert ou une suppression, le nombre d'objets affectés sera retourné. Pour les opérations d'insertion, cette valeur sera toujours de 0.

    wtimeout

    Si l'option précédente a expiré en attendant la réplication.

    waited

    Le temps que l'opération doit attendre avant d'expirer.

    wtime

    Si w a été défini et que l'opération réussit, ce sera le temps prit pour la réplication vers les w serveurs.

    upserted

    Si un upsert survient, ce champ contiendra le champ _id du nouvel enregistrement. Pour les upserts, soit ce champ, soit le champ updatedExisting sera présent (à moins qu'une erreur ne survienne).

    updatedExisting

    Si un upsert met à jour un élément existant, ce champ vaudra TRUE. Pour les upserts, soit ce champ, soit le champ upserted sera présent (à moins qu'une erreur ne survienne).

    Erreurs / Exceptions

    Lance une exception MongoCursorTimeoutException si le document inséré est vide ou s'il contient des clés d'une longueur de zéro. Le fait de tenter d'insérer un objet avec des propriétés protégées ou privées causera une erreur de type "clé d'une longueur zéro".

    Lance une exception MongoCursorException si l'option "w" est définie, et que l'écriture échoue.

    Lance une exception MongoCursorTimeoutException si l'option "w" est définie à une valeur supérieure à 1 et que l'opération prend plus de temps que MongoCursor::$timeout millisecondes à se terminer. Ceci ne va pas mettre fin à l'opération sur le serveur, ce n'est qu'un délai d'attente maximal côté client. L'unité pour MongoCollection::$wtimeout est la milliseconde.

    Historique

    Version Description
    1.5.0

    Ajout de l'option "wTimeoutMS", qui remplace "wtimeout". Emets une alerte de niveau E_DEPRECATED lorsque "wtimeout" est utilisée.

    Ajout de l'option "socketTimeoutMS", qui remplace "timeout". Emets une alerte de niveau E_DEPRECATED lorsque "timeout" est utilisée.

    Emets une alerte de niveau E_DEPRECATED lorsque "safe" est utilisée.

    1.3.4 Ajout de l'option "wtimeout".
    1.3.0

    Ajout de l'option "w".

    Le paramètre options n'accepte plus de booléen pour indiquer une écriture reconnue. A la place, utilisez la syntaxe array('w' => 1) (comportement par défaut de MongoClient).

    1.2.0 Ajout de l'option "timeout".
    1.0.11 Se déconnecte lors d'erreurs "not master" si "safe" est utilisé.
    1.0.9

    Ajout de la possibilité de passer des entiers à l'option "safe" (auparavant, seuls les booléens étaient acceptés).

    Ajotu de l'option "fsync".

    Le type retourné a changé. C'est maintenant un tableau contenant les informations d'erreur si l'option "safe" est utilisée, sinon, c'est un booléen, comme auparavant.

    1.0.2 Modification du second paramètre en un tableau d'options. Avant la version 1.0.2, le second paramètre était un booléen indiquant l'option "safe".
    1.0.1 Lance une exception MongoCursorException si l'option "safe" est définie et que l'insertion échoue.

    Exemples

    Exemple #1 Exemple avec MongoCollection::insert() _id

    Un champ _id sera ajouté au document inséré s'il n'est pas présent. Suivant comment le paramètre est passé, un _id généré peut ou non être disponible pour le code appelant.

    <?php

    $m     = new MongoClient();
    $collection = $m->selectCollection('test', 'phpmanual');

    // Si un tableau litéral est utilisé, il n'y a aucun moyen d'accéder à l'_id généré
    $collection->insert(array('x' => 1));

    // L'_id est disponible pour un tableau passé par valeur
    $a = array('x' => 2);
    $collection->insert($a);
    var_dump($a);

    // L'_id n'est pas disponible sur un tableau passé par référence
    $b = array('x' => 3);
    $ref = &$b;
    $collection->insert($ref);
    var_dump($ref);

    // L'_id est disponible si la fonction ne déclenche pas de copy-on-write
    function insert_no_cow($collection, $document)
    {
            $collection->insert($document);
    }

    $c = array('x' => 4);
    insert_no_cow($collection, $c);
    var_dump($c);

    // L'_id n'est pas disponible si la fonction déclenche un copy-on-write
    function insert_cow($collection, $document)
    {
            $document['y'] = 1;
            $collection->insert($document);
    }

    $d = array('x' => 5);
    insert_cow($collection, $d);
    var_dump($d);

    ?>

    L'exemple ci-dessus va afficher quelque chose de similaire à :

    array(2) {
  ["x"]=>
  int(2)
  ["_id"]=>
  object(MongoId)#4 (0) {
  }
}
array(1) {
  ["x"]=>
  int(3)
}
array(2) {
  ["x"]=>
  int(4)
  ["_id"]=>
  object(MongoId)#5 (0) {
  }
}
array(1) {
  ["x"]=>
  int(5)
}

    Exemple #2 Exemple d'une écriture reconnue avec MongoCollection::insert()

    Cet exemple montre l'insertion de 2 éléments avec le même _id, ce qui entraine l'émission d'une exception MongoCursorException vu que le paramètre w a été défini.

    <?php

    $person     = array("name" => "Joe", "age" => 20);
    $collection->insert($person);

    // Maintenant, $person a un champ _id, aussi, si vous le sauvegardez à nouveau,
    // une exception sera émise
    try {
            $collection->insert($person, array("w" => 1));
    } catch(    MongoCursorException $e) {
        echo     "Vous ne pouvez pas sauvegarder la même personne 2 fois !\n";
    }

    ?>

    Voir aussi

    add a note add a note

    User Contributed Notes 6 notes

    up
    3
    Christer Edvartsen
    13 years ago
    Also worth noting is that the MongoCollection::insert() method accepts objects as the first argument as well as arrays.

    <?php
    $data     = new stdClass;
    $data->foo = 'foo';
    $data->bar = 'bar';
    $collection->insert($data);
    var_dump($data->_id); // An instance of MongoId
    ?>

    You can use other classes as well, but MongoCollection::insert() will fail if the object contains any protected or private properties. Public properties listed in the class will also be inserted:

    <?php
    class SomeClass {
        public     $foo = 'bar';
        public     $bar = 'foo';
    }

    $data = new SomeClass;
    $data->foobar = 42;
    $collection->insert($data);
    var_dump($data->_id); // An instance of MongoId
    ?>

    will result in a document with four elements:

    _id => some mongoid
    foo => 'bar'
    bar => 'foo'
    foobar => 42
    up
    2
    gmail.com@mspreij
    11 years ago
    "Note: If the parameter does not have an _id key or property, a new MongoId instance will be created and assigned to it."

    Note on note: this is true even if the insert *fails* (because of, say, duplicate key error). So even if no new document was inserted, the supplied array will still have a new MongoID key ->_id after the ->insert().

    (which can make an attempted update after that fail, because you cannot update the _id value of a document..)
    up
    1
    root at php dot net
    11 years ago
    _id and MongoId can be a source of problems that can make what would seem a trivial operation potentially complicated.

    MongoId is not as predictable or safe as mysql's auto increment (an example that most PHP developers will be familiar with). _id is generated by the client rather than the server and so does not guarantee that it will be collision free.

    By comparison, server side auto_increment mechanisms that PHP programmers might typically be used to wont collide until every single id had been used and with 64bits you can ensure this will almost never happen. You will also know when your table is getting full, and you can predict the rate. Most importantly, no matter the mechanism, being server side guarantees two clients wont collide. Mongo's behaviour is different to this.

    Generally speaking inserting without specifying _id will tend to work, but there are some cases where is can fail or is particularly prone to failure.

    The total size I believe is 96 bits. This might seem like a lot but the value is not created randomly. It is generated like this:

    $unixtime . $machine_id . $pid . $counter

    The counter starts from zero and is attached to each instance of MongoClient thus two MongoClient connections to the same server will almost certainly not work (produce a collision):

    $m=new MongoWrapper();
    $m->insert([0]);
    $m=new MongoWrapper();
    $m->insert([1]);

    If MongoWrapper is not using a singleton for the connection or something to the same effect, the second call will most likely have the same unixtime. It will certainly have the same machine_id, pid and counter. The insert will fail.

    If you are not using a singleton, this will work:

    $m=new MongoWrapper();
    $m->insert([0]);
    $m->insert([1]);

    You may also have difficulties in a multiple machine environment.

    machine_id is a hash of gethostname. This is not guaranteed to be unique across machines. Some people do not set hostnames at all. If you do not ensure that your machines all have unique hostnames then if in the same second, two machines run a script that inserts, the second will have a 1 in 2^15 chance of colliding (assuming the most common PID max). Depending on how the system handles pids, the probability may actually be a little less. In short, make sure any host accessing your mongodb has a hostname that is unique among any other host accessing your mongodb.

    I've seen some specs specify that counter should start from a random value but I highly recommend against this as it merely hides/obscures the problem.
    up
    1
    mike at eastghost dot com
    10 years ago
    Attempting to insert() an array containing a NULL value followed by a blank space, in a non-utf8 encoding, results in the entire array (and all of its data) being ignored and the $opts array parameter being substituted instead as the data.
    up
    0
    cuisdy at gmail dot com
    12 years ago
    Another rarity to keep in mind. Passing references has the same effect as passing a referenced object. Even if there's no different for PHP between those two, it's probably not evident. So, this code would not have the _id field added to $a:

    <?php

    $b     = &$a;

    /* ... more code here ... */

    $m = new MongoClient;
    $collection = $m->test->phpmanual;

    $a = array('x' => 12);

    $collection->insert($a);
    var_dump($a);
    // array(1) { ["x"]=> int(12) }

    ?>

    I've made the assignment above to show how this situation could happen, if you reassigned a var, for example. But it could be some normal referencing after giving $a its final value (but before calling insert), and the consequence would be the same: if a var is referenced, it won't get the _id appended.
    up
    0
    John S.
    12 years ago
    Note, that the _id field will only be added to an inserted array if it does not already exist in the supplied array:

    <?php
    $data     = array('x' => 12);
    var_dump($data);
    $collection->insert($data);
    var_dump($data);
    ?>

    Will output something like:

    array(1) {
      ["x"]=>
      int(12)
    }
    array(2) {
      ["x"]=>
      int(12)
      ["_id"]=>
      object(MongoId)#196 (1) {
        ["$id"]=>
        string(24) "503e21fc0605290912000000"
      }
    }

    however,

    $data = array('x' => 12, '_id' => NULL);
    var_dump($data);
    $collection->insert($data);
    var_dump($data);

    will not have the same result:

    array(2) {
      ["x"]=>
      int(12)
      ["_id"]=>
      NULL
    }
    array(2) {
      ["x"]=>
      int(12)
      ["_id"]=>
      NULL
    }
    add a note add a note
    To Top