Impossible de créer un index dans mongodb, "clé trop grande pour indexer"

Je suis de la création de l'indice en mongodb avoir 10 millions de documents, mais d'erreur suivant

db.logcollection.ensureIndex({"Module":1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 3,
        "ok" : 0,
        "errmsg" : "Btree::insert: key too large to index, failing play.logcollection.$Module_1 1100 { : \"RezGainUISystem.Net.WebException: The request was aborted: The request was canceled.\r\n   at System.Net.ConnectStream.InternalWrite(Boolean async, Byte...\" }",
        "code" : 17282
}

S'il vous plaît aidez-moi comment createindex dans mongodb,

source d'informationauteur Sandeep.maurya | 2015-01-06

  1. 27

    MongoDB ne pas créer un index sur une collection si l'entrée d'index pour un document existant dépasse la la clé d'index de limite (1024 octets). Vous pouvez cependant créer un index haché ou l'index de texte à la place:

    db.logcollection.ensureIndex({"Module":"hashed"})

    ou

    db.logcollection.ensureIndex({"Module":"text"})
  2. 17

    Vous pouvez silencieux ce comportement par le lancement de mongod exemple avec la commande suivante:

    mongod --setParameter failIndexKeyTooLong=false

    ou en exécutant la commande suivante à partir mongoShell

    db.getSiblingDB('admin').runCommand( { setParameter: 1, failIndexKeyTooLong: false } )

    Si vous assuré que votre champ de dépasser la limite que très rarement, alors
    une façon de résoudre ce problème est de diviser votre terrain (qui provoque l'index hors de la limite) dans des pièces par longueur en octets < 1 par exemple, pour le champ val je voudrais découper en n-uplet de champs val_1, val_2 et ainsi de suite. Mongo stocke le texte en utf-8 valide valeurs. Cela signifie que vous avez besoin d'une fonction qui permet de diviser des chaînes utf-8 correctement. 

       def split_utf8(s, n):
    """
    (ord(s[k]) & 0xc0) == 0x80 - checks whether it is continuation byte (actual part of the string) or jsut header indicates how many bytes there are in multi-byte sequence

    An interesting aside by the way. You can classify bytes in a UTF-8 stream as follows:

    With the high bit set to 0, it's a single byte value.
    With the two high bits set to 10, it's a continuation byte.
    Otherwise, it's the first byte of a multi-byte sequence and the number of leading 1 bits indicates how many bytes there are in total for this sequence (110... means two bytes, 1110... means three bytes, etc).
    """
    s = s.encode('utf-8')
    while len(s) > n:
        k = n
        while (ord(s[k]) & 0xc0) == 0x80:
            k -= 1
        yield s[:k]
        s = s[k:]
    yield s

    Ensuite, vous pouvez définir votre index composé:

    db.coll.ensureIndex({val_1: 1, val_2: 1, ...}, {background: true})

    ou plusieurs index pour chaque val_i:

    db.coll.ensureIndex({val_1: 1}, {background: true})
db.coll.ensureIndex({val_1: 2}, {background: true})
...
db.coll.ensureIndex({val_1: i}, {background: true})

    Important: Si vous envisagez d'utiliser votre champ d'index composé, alors soyez prudents avec le deuxième argument pour split_utf8 fonction. À chaque document que vous avez besoin de retirer la somme des octets de chaque valeur de champ qui composent votre clé d'index par exemple, pour l'indice (a:1, b:1, val: 1) 1024 - sizeof(value(a)) - sizeof(value(b))

    Dans tous les autres cas, utilisez soit de hachage ou texte index.

  3. 1

    Que différentes personnes a souligné dans les réponses, l'erreur key too large to index signifie que vous tentez de créer un index sur le champ ou dans les champs qui dépasse 1024 octets de longueur.

    En ASCII termes, 1024 octets généralement se traduit par environ 1024 caractères.

    Il est pas de solution pour cela, car c'est une limite intrinsèque définie par MongoDB comme mentionné dans MongoDB les Limites et les Seuils de page:

    La taille totale d'une entrée d'index, ce qui peut inclure structurels généraux en fonction de la BFILS type, doit être inférieur à 1024 octets.

    Tournant sur le failIndexKeyTooLong erreur n'est pas une solution, comme mentionné dans le paramètres du serveur de la page de manuel:

    ...ces opérations sont réussi à insérer ou de modifier un document, mais le ou les index ne serait pas inclure des références au document.

    Ce que cette phrase signifie que le document concerné sera pas être inclus dans l'index, et peut-être manquant dans les résultats de la requête.

    Par exemple:

    > db.test.insert({_id: 0, a: "abc"})

> db.test.insert({_id: 1, a: "def"})

> db.test.insert({_id: 2, a: <string more than 1024 characters long>})

> db.adminCommand( { setParameter: 1, failIndexKeyTooLong: false } )

> db.test.find()
{"_id": 0, "a": "abc"}
{"_id": 1, "a": "def"}
{"_id": 2, "a": <string more than 1024 characters long>}
Fetched 3 record(s) in 2ms

> db.test.find({a: {$ne: "abc"}})
{"_id": 1, "a": "def"}
Fetched 1 record(s) in 1ms

    En forçant MongoDB pour ignorer la failIndexKeyTooLong erreur de la dernière requête ne contient pas le document concerné (c'est à dire le document avec _id: 2 est manquant dans le résultat), ainsi, la requête a abouti à un mauvais jeu de résultats.