Zeichenfolge Feld Wert Länge in MongoDB

Den Datentyp des Feldes ist String. Ich möchte zum abrufen der Daten, bei denen Zeichen Länge des Feldnamens ist größer als 40.

Versuchte ich diese Abfragen aber wieder Fehler.
1.

db.usercollection.find(
{$where: "(this.name.length > 40)"}
).limit(2);

output :error: {
    "$err" : "TypeError: Cannot read property 'length' of undefined near '40)' ",
    "code" : 16722
}

dies ist die Arbeit in 2.4.9 Aber meine version ist 2.6.5

InformationsquelleAutor der Frage SURYA GOKARAJU | 2015-04-11

88

Für MongoDB 3.6 und neuer:

Den $expr - operator ermöglicht die Verwendung von aggregation Ausdrücke in der Abfrage-Sprache, so können Sie die Hebelwirkung, die Verwendung von $strLenCP Betreiber überprüfen Sie die Länge der Zeichenfolge wie folgt:
```
db.usercollection.find({ 
    "name": { "$exists": true },
    "$expr": { "$gt": [ { "$strLenCP": "$name" }, 40 ] } 
})
```
Für MongoDB 3.4 und neuere Versionen:

Können Sie auch mit dem aggregation-framework mit der $schwärzen pipeline-Betreiber, können Sie proccess die logische Bedingung mit der $dir operator, und verwendet die spezielle Operationen $$BEHALTEN zu "halten" das Dokument, in dem die logische Bedingung wahr ist oder $$PRUNE zu "entfernen" das Dokument, in dem die Bedingung war falsch.

Dieser Vorgang ist ähnlich wie mit einem $project pipeline, wählt die Felder in der Sammlung und erstellt ein neues Feld, das hält das Ergebnis der logischen Bedingung Abfragen und dann einen anschließenden $matchaußer dass $schwärzen verwendet eine einzige pipeline-Stufe, die ist effizienter.

Als für die logische Bedingung, es gibt String Aggregation Betreiberdie Sie verwenden können $strLenCP Betreiber überprüfen Sie die Länge der Zeichenfolge. Wenn die Länge $gt einen bestimmten Wert, dann ist dies ein wahres match und das Dokument wird "gehalten". Sonst ist er "beschnitten" und verworfen.

Betrachten Sie zum ausführen der folgenden Aggregat-Betrieb zeigt das obige Konzept:
```
db.usercollection.aggregate([
    { "$match": { "name": { "$exists": true } } },
    {
        "$redact": {
            "$cond": [
                { "$gt": [ { "$strLenCP": "$name" }, 40] },
                "$$KEEP",
                "$$PRUNE"
            ]
        }
    },
    { "$limit": 2 }
])
```
Wenn mit $woversuchen Sie Ihre Abfrage ohne die umschließenden Klammern:
```
db.usercollection.find({$where: "this.name.length > 40"}).limit(2);
```
Einer besseren Abfrage wäre zu überprüfen, für den Bereich der Existenz und überprüfen Sie dann die Länge:
```
db.usercollection.find({name: {$type: 2}, $where: "this.name.length > 40"}).limit(2); 
```
oder:
```
db.usercollection.find({name: {$exists: true}, $where: "this.name.length > 
40"}).limit(2); 
```
MongoDB wertet nicht-$wo Abfrage-Operationen vor $wo Ausdrücken und nicht$where Abfrage-Anweisungen kann einen index verwenden. Eine viel bessere Leistung zu speichern, die Länge der Zeichenfolge als ein weiteres Feld, und dann können Sie den index oder darauf suchen; anwenden $wo wird viel langsamer im Vergleich. Es wird empfohlen, die Verwendung von JavaScript-Ausdrücken und den $wo Betreiber als letzten Ausweg, wenn Sie nicht die Struktur der Daten in einer anderen Weise, oder wenn Sie es mit einem
kleine Teilmenge der Daten.

Einen anderen und schnelleren Ansatz, vermeidet die Verwendung der $wo Betreiber ist die $regex Betreiber. Betrachten Sie das folgende Muster, das sucht
```
db.usercollection.find({"name": {"$type": 2, "$regex": /^.{41,}$/}}).limit(2); 
```
Hinweis - Von der docs:

Ob ein index existiert für den Bereich, dann ist MongoDB entspricht der regulären
Ausdruck gegen die Werte in den index ein, die schneller sein können als eine
Sammlung Scannen. Eine weitere Optimierung kann auftreten, wenn die regelmäßige
Ausdruck ist ein "Präfix-Ausdruck", was bedeutet, dass alle potenziellen
Spiele starten mit der gleichen Zeichenfolge. Dies ermöglicht MongoDB zu konstruieren
"Reihe" aus, dass Präfix-und nur gegen diese Werte aus der
index, fallen in diesen Bereich.

Ist ein regulärer Ausdruck ein prefix Ausdruck", wenn es startet mit einer
caret (^) oder Links Anker (\A), gefolgt von einer Reihe von einfachen
Symbole. Zum Beispiel, die regex /^abc.*/ werden optimiert, indem
passenden nur gegen die Werte aus dem index, die beginnen mit abc.

Zusätzlich, während /^a/, /^a.*/, und /^a.*$/ entsprechen, äquivalent
Zeichenfolgen, haben Sie unterschiedliche Leistungsmerkmale. Alle diese
Ausdrücke, die einen index verwenden, wenn ein geeigneter index vorhanden ist, jedoch
/^a.*/und /^a.*$/ langsamer sind. /^a/ stoppen können scan nach
passende Präfix.

InformationsquelleAutor der Antwort chridam
2

Ich hatte ein ähnliches Szenario, aber in meinem Fall string ist kein 1st-level-Attribut. Es ist in einem Objekt. Hier konnte ich nicht finden, eine geeignete Antwort für Sie. Also dachte ich, Teile ich meine Lösung mit Euch allen(Hoffe, das wird helfen, jemand mit einer ähnlichen Art von problem).
```
Parent Collection 

{
"Child":
{
"name":"Random Name",
"Age:"09"
}
}
```
Ex: Wenn wir brauchen, um nur die Sammlungen, dass der name des Kindes wird die Länge größer als 10 Zeichen.
```
 db.getCollection('Parent').find({$where: function() { 
for (var field in this.Child.name) { 
    if (this.Child.name.length > 10) 
        return true;

}
}})
```
InformationsquelleAutor der Antwort Udara Gunathilake

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.