Nicht create index in mongodb "- Taste zu groß, um index"

Ich Schaffe index in mongodb mit 10 Millionen Datensätze aber folgenden Fehler

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
}

Bitte helft mir, wie createindex in mongodb,

InformationsquelleAutor der Frage Sandeep.maurya | 2015-01-06

  1. 31

    MongoDB wird nicht erstellen Sie einen index für eine Sammlung, wenn der index-Eintrag für ein vorhandenes Dokument überschreitet die index-Taste begrenzen (1024 bytes). Sie können jedoch erstellen ein Hash-index oder text-index statt:

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

    oder

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

    InformationsquelleAutor der Antwort anhlc

  2. 18

    Können Sie die Stille dieses Verhalten durch die Einführung mongod-Instanz mit folgendem Befehl:

    mongod --setParameter failIndexKeyTooLong=false

    oder durch Ausführung des folgenden Befehls von mongoShell

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

    Wenn Sie gewährleistet, dass sich Ihr Gebiet überschreiten die Grenze sehr selten, dann
    eine Möglichkeit, dieses Problem zu lösen ist, indem Sie das Feld (das bewirkt, dass der index out of limit) in teilen von Bytelänge < 1KB z.B. für Feld val würde ich es aufgeteilt in ein Tupel von Feldern val_1, val_2 und so weiter. Mongo speichert text als utf-8 mit gültigen Werten. Es bedeutet, dass Sie eine Funktion benötigen, teilen utf-8-Zeichenfolgen ordnungsgemäß. 

       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

    Dann definieren Sie Ihre zusammengesetzte index:

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

    oder mehrere Indizes pro 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})

    Wichtig: Wenn Sie erwägen, Ihr Feld im zusammengesetzten index, dann vorsichtig sein, mit dem zweiten argument für split_utf8 Funktion. Bei jedem Dokument müssen Sie entfernen Sie die Summe der bytes, die von jedem Feld einen Wert, aus denen Ihr index-Schlüssel (z.B. für den index (a:1, b:1, val: 1) 1024 - sizeof(value(a)) - sizeof(value(b))

    In allen anderen Fällen verwenden Sie entweder hash oder text Indizes.

    InformationsquelleAutor der Antwort Rustem K

  3. 2

    Als andere Menschen, hat darauf hingewiesen, die Antworten, der Fehler key too large to index bedeutet, dass Sie versuchen, erstellen Sie einen index auf Feld oder die Felder, größer als 1024 bytes Länge.

    In ASCII-Begriffe, 1024 bytes, die typischerweise übersetzt, um etwa 1024 Zeichen lang sein.

    Es ist keine Lösung für diese, da dies eine intrinsische Grenze gesetzt von MongoDB wie bereits in MongoDB Grenzen und Schwellen Seite:

    Die Gesamtgröße des index, die strukturellen overhead je nach bsohn geben, muss kleiner sein als 1024 bytes.

    Einschalten des failIndexKeyTooLong Fehlers keine Lösung ist, wie erwähnt, in server-Parameter Handbuch-Seite:

    ...diese Operationen erfolgreich einfügen oder ändern eines Dokuments, sondern den index oder die Indizes würden keine Verweise auf das Dokument.

    Was dieser Satz bedeutet, ist, dass das problematische Dokument wird nicht in den index aufgenommen werden und fehlen möglicherweise die Abfrage-Ergebnisse.

    Beispiel:

    > 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

    Zwingt und MongoDB zu ignorieren, die failIndexKeyTooLong Fehler, der letzten Abfrage nicht enthalten das problematische Dokument (d.h. das Dokument mit _id: 2 fehlen, ist das Ergebnis), also die Abfrage ergab das falsche Ergebnis gesetzt.

    InformationsquelleAutor der Antwort Kevin Adistambha

  4. 1

    Beim laufen in die " index-Taste begrenzen " die Lösung hängt von den Bedürfnissen der Ihr schema. In extrem seltenen Fällen, Schlüssel passenden auf einen Wert von > 1024 bytes ist eine design-Anforderung. In der Tat, fast alle Datenbanken Einführung einer index-Taste limit-Einschränkung, aber in der Regel etwas konfigurierbar im legacy-relationale DBs (Oracle/MySQL/PostgreSQL), so dass Sie leicht zu Schießen selbst in den Fuß.

    Für die schnelle Suche, ein "text" - index dient der Optimierung der Suche und pattern-matching auf lange Textfelder, und ist gut geeignet, um die use-case. Aber, mehr allgemein, eine Eindeutigkeit, die auf einen langen text Werte ist eine Voraussetzung. Und "text" - Indizes Verhalten sich nicht wie einen eindeutigen skalaren Wert mit dem unique-flag gesetzt
    { unique: true } (mehr wie ein array von Zeichenfolgen in das Feld).

    Inspiriert von MongoDb GridFS ist, uniqueness-Prüfungen können leicht implementiert werden, indem ein "md5" - Feld, um das Dokument und die Erstellung einer eindeutigen skalaren index auf. In der Art, wie Sie einen benutzerdefinierten eindeutigen Hash-index. Dies ermöglicht eine nahezu unbegrenzte (~ 16 MB) text Feld der Länge, dass ist indiziert für die Suche und einzigartig in der Sammlung. 

    const md5 = require('md5');
const mongoose = require('mongoose');

let Schema = new mongoose.Schema({
  text: {
    type: String,
    required: true,
    trim: true,
    set: function(v) {
        this.md5 = md5(v);
        return v;
    }
  },
  md5: {
    type: String,
    required: true,
    trim: true
  }
});

Schema.index({ md5: 1 }, { unique: true });
Schema.index({ text: "text" }, { background: true });

    InformationsquelleAutor der Antwort JoelABair

Schreibe einen Kommentar