MongoDB: Ist es möglich eine Abfrage ohne Berücksichtigung der Groß- und Kleinschreibung durchzuführen?

Beispiel:

> db.stuff.save({"foo":"bar"});

> db.stuff.find({"foo":"bar"}).count();
1
> db.stuff.find({"foo":"BAR"}).count();
0

Kommentar zu dem Problem

Da MongoDB 3.2 Sie können den Befehl groß- / Kleinschreibung zu suchen, die mit $caseSensitive: false. Siehe: docs.mongodb.org/manual/reference/operator/query/text/... Kommentarautor: martin

Beachten Sie, dass für text-Indizes nur. Kommentarautor: Willem D'Haeseleer

InformationsquelleAutor der Frage Luke Dennis | 2009-12-07

case-insensitive mongodb

247

Könnte man eine regex.

In deinem Beispiel wäre das:
```
db.stuff.find( { foo: /^bar$/i } );
```
Ich muss sagen, obwohl, vielleicht könnten Sie einfach downcase (oder upcase) der Wert auf die Art und Weise, statt dass die extra Kosten jedes mal, wenn Sie es finden. Offensichtlich ist dies nicht funktioniert für die Namen von Personen und so, aber vielleicht use-cases wie tags.

InformationsquelleAutor der Antwort rfunduk
187

UPDATE:

Die original-Antwort ist nun obsolet. Mongodb unterstützt jetzt erweiterte Volltext-Suche mit vielen Funktionen.

ORIGINAL ANTWORT:

Es sollte angemerkt werden, dass die Suche mit regex die groß-und Kleinschreibung /i bedeutet, dass mongodb kann die Suche durch den index, also die Abfragen gegen große datasets kann eine lange Zeit dauern.

Sogar mit kleinen Datenmengen, es ist nicht sehr effizient. Sie nehmen eine viel größere cpu-hit, als Sie Ihre Abfrage sichert zu, das könnte zu einem Problem werden, wenn Sie versuchen, zu erreichen Skala.

Als alternative können Sie einen Großbuchstaben kopieren und suchen gegen. Zum Beispiel habe ich eine Tabelle User hat einen Benutzernamen, die gemischte groß-und Kleinschreibung, aber die id ist eine in Großbuchstaben Kopie der Benutzername. Dies gewährleistet die groß-und Kleinschreibung Vervielfältigung ist unmöglich (sowohl "Foo" und "foo" wird nicht erlaubt sein), und ich kann die Suche durch id = username.toUpperCase (), um eine case-insensitive Suche nach Benutzernamen.

Wenn das Feld groß ist, wie der Körper der Nachricht befindet, duplizieren von Daten ist wahrscheinlich nicht eine gute option. Ich glaube, mit einer von außen indexer wie Apache Lucene ist die beste option in diesem Fall.

InformationsquelleAutor der Antwort Dan
56

Beachten dass das vorhergehende Beispiel:
```
db.stuff.find( { foo: /bar/i } );
```
verursachen wird, alle Einträge mit bar mit der Abfrage übereinstimmen ( bar1, barxyz, openbar ), könnte es sehr gefährlich für einen Benutzernamen-Suche über eine auth-Funktion ...

Können Sie brauchen, um es nur übereinstimmungen des Suchbegriffs mit den entsprechenden regexp-syntax:
```
db.stuff.find( { foo: /^bar$/i } );
```
Sehen http://www.regular-expressions.info/ für die syntax-Hilfe zu regulären Ausdrücken

InformationsquelleAutor der Antwort jflaflamme
51

Wenn Sie brauchen, um das regexp aus einer variable, das ist ein viel besserer Weg, es zu tun: https://stackoverflow.com/a/10728069/309514

Können Sie dann etwas wie:
```
var string = "SomeStringToFind";
var regex = new RegExp(["^", string, "$"].join(""), "i");
//Creates a regex of: /^SomeStringToFind$/i
db.stuff.find( { foo: regex } );
```
Dies hat den Vorteil, dass mehr programmatische oder Sie können ein performance-boost durch kompilieren vor der Zeit, wenn Sie wiederverwendet, eine Menge.

InformationsquelleAutor der Antwort Fotios
16

Als von Mongodb 3.4 verwenden Sie eine case-insensitive Sortierung index. Dies ist der Schnellste Weg, um eine case-insensitive Suche über die Datensätze der immer größeren Größe. Ich persönlich per E-Mail einer der Gründer der bitte, dies funktioniert, und er hat es geschafft! (Es war ein Problem auf JIRA für etwa 5 Jahren, und viele die angeforderte Funktion). Hier ist, wie es funktioniert:

Einer groß- /Kleinschreibung index wird durch angeben einer Sortierung mit einer Stärke von entweder 1 oder 2. Sie können erstellen Sie eine case-insensitive-index so:
```
db.myCollection.createIndex({city: 1}, {collation: {locale: "en", strength: 2}});
```
, Oder Sie können es für die ganze Sammlung, die standardmäßig beim erstellen der Datenbank etwa so:
```
db.createCollection("Cities",{collation: {locale: "en",strength:2}});
```
Und verwenden Sie es wie diese:
```
db.myCollection.find({city: "new york"}).collation({locale: "en", strength: 2});
```
Diese wird wieder "New York", "new york", etc.

Alternativ können Sie alle Indizes verwenden eine Sortierung standardmäßig, wenn Sie die Sammlung wie diese:
```
db.createCollection("cities",{collation:{locale: "en", strength: 2}});
```
Vorteil dieser Methode ist die deutlich verbesserte Effizienz und Geschwindigkeit bei größeren Datenmengen.

Weitere Infos: https://jira.mongodb.org/browse/SERVER-90 , https://docs.mongodb.com/manual/reference/collation/

InformationsquelleAutor der Antwort user3413723

db.zipcodes.find({city : "NEW YORK"}); //Case-sensitive
db.zipcodes.find({city : /NEW york/i}); //Note the 'i' flag for case-insensitivity

InformationsquelleAutor der Antwort rshivamca

TL;DR

Richtige Weg, dies zu tun in mongo

Nicht Verwenden RegExp

Gehen natürlichen Und verwenden mongodb die eingebaute Indizierung , Suche

Schritt 1 :

db.articles.insert(
   [
     { _id: 1, subject: "coffee", author: "xyz", views: 50 },
     { _id: 2, subject: "Coffee Shopping", author: "efg", views: 5 },
     { _id: 3, subject: "Baking a cake", author: "abc", views: 90  },
     { _id: 4, subject: "baking", author: "xyz", views: 100 },
     { _id: 5, subject: "Café Con Leche", author: "abc", views: 200 },
     { _id: 6, subject: "Сырники", author: "jkl", views: 80 },
     { _id: 7, subject: "coffee and cream", author: "efg", views: 10 },
     { _id: 8, subject: "Cafe con Leche", author: "xyz", views: 10 }
   ]
)

Schritt 2 :

Müssen, erstellen Sie den index auf, welcher TEXT Feld, das Sie durchsuchen möchten , ohne Indizierung, Abfrage extrem langsam

db.articles.createIndex( { subject: "text" } )

Schritt 3 :

db.articles.find( { $text: { $search: "coffee",$caseSensitive :true } } )  //FOR SENSITIVITY
db.articles.find( { $text: { $search: "coffee",$caseSensitive :false } } ) //FOR INSENSITIVITY

InformationsquelleAutor der Antwort vijay

9

Mongo (aktuelle version 2.0.0) nicht erlaubt, die groß- /Kleinschreibung sucht gegen indizierten Feldern - siehe Ihre Dokumentation. Für nicht-indizierte Felder, die regexes aufgeführt, die in den anderen Antworten sollten in Ordnung sein.

InformationsquelleAutor der Antwort Aidan Feldman
5

Die beste Methode ist in Ihrer Sprache der Wahl, wenn Sie ein Modell erstellen wrapper für Ihre Objekte, haben Ihre save () - Methode Durchlaufen eine Reihe von Feldern, die Sie suchen sein werden, auf die auch indiziert; diese Felder sollten Kleinbuchstaben Kollegen, die sind dann für die Suche verwendet.

Jedes mal, wenn Sie das Objekt erneut gespeichert wird, die Kleinbuchstaben Eigenschaften werden dann geprüft und aktualisiert mit den änderungen zu den wichtigsten Eigenschaften. Das macht es so können Sie die Suche effizient, aber blenden Sie die zusätzliche Arbeit benötigt, um update der lc-Felder jedes mal.

Kleinschreibung Felder könnte ein Schlüssel:Wert-Objekt speichern oder einfach nur den Namen des Feldes mit einem Präfix lc_. Ich benutze die zweite zu vereinfachen Abfragen (deep-Objekt Abfragen kann manchmal verwirrend sein).

Hinweis: Sie indizieren möchten die lc_ Felder, nicht die wichtigsten Felder, auf denen Sie beruhen, aus.

InformationsquelleAutor der Antwort RobKohr
5

Angenommen, Sie möchten die Suche "Spalte" in "Tabelle" und Sie wollen Fall insenstive suchen. Die beste und effizienteste Weise ist, wie unten;
```
//create empty JSON Object
mycolumn = {};

//check if column has valid value
if(column) {
    mycolumn.column = {$regex: new RegExp(column), $options: "i"};
}
Table.find(mycolumn);
```
Obige code fügt nur Ihrer Suche Wert als RegEx und suchen im mit insensitve Kriterien mit "i" als option.

Alle das beste.

InformationsquelleAutor der Antwort Ankur Soni
5

Eine sehr wichtige Sache im Auge zu behalten, wenn über eine Regex-basierten Abfrage -, Wenn Sie tun dies für ein login-system, Flucht jedes einzelne Zeichen Sie sind auf der Suche nach, und vergessen Sie nicht, die ^ und $ Betreiber. Lodash hat eine nette Funktion für diese, sollten Sie es bereits:
```
db.stuff.find({$regex: new RegExp(_.escapeRegExp(bar), $options: 'i'})
```
Warum? Stellen Sie sich eine Benutzer-Eingabe .* wie sein username. Das wäre mit allen Benutzernamen, sodass eine Anmeldung nur durch erraten des Passworts eines jeden Benutzers.

InformationsquelleAutor der Antwort Ziao

Mit Mungo dieser arbeitete für mich:

var find = function(username, next){
    User.find({'username': {$regex: new RegExp('^' + username, 'i')}}, function(err, res){
        if(err) throw err;
        next(null, res);
    });
}

InformationsquelleAutor der Antwort ChrisRich

3

Dem aggregation-framework wurde eingeführt, mongodb 2.2 . Sie können die string-operator "$strcasecmp", um eine groß- /Kleinschreibung-Vergleich zwischen den Zeichenfolgen. Es ist mehr empfohlen und einfacher als die Verwendung von regex.

Hier ist das offizielle Dokument, das auf der aggregation Befehl operator: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp .

InformationsquelleAutor der Antwort Jogue Wasin

Können Sie groß-und Kleinschreibung Indizes:

Folgende Beispiel erstellt eine Sammlung mit keine Standard-Sortierung, fügt dann einen index auf das Feld name mit einem groß-und Kleinschreibung Sortierung. Internationale Komponenten für Unicode

/* strength: CollationStrength.Secondary
* Secondary level of comparison. Collation performs comparisons up to secondary * differences, such as diacritics. That is, collation performs comparisons of 
* base characters (primary differences) and diacritics (secondary differences). * Differences between base characters takes precedence over secondary 
* differences.
*/
db.users.createIndex( { name: 1 }, collation: { locale: 'tr', strength: 2 } } )

Verwenden Sie den index, müssen die Abfragen geben Sie die gleiche Sortierung.

db.users.insert( [ { name: "Oğuz" },
                            { name: "oğuz" },
                            { name: "OĞUZ" } ] )

//does not use index, finds one result
db.users.find( { name: "oğuz" } )

//uses the index, finds three results
db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 2 } )

//does not use the index, finds three results (different strength)
db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 1 } )

oder können Sie eine Sammlung erstellen mit der Standard-Sortierung:

db.createCollection("users", { collation: { locale: 'tr', strength: 2 } } )
db.users.createIndex( { name : 1 } ) //inherits the default collation

InformationsquelleAutor der Antwort Gencebay D.

Habe ich einen einfachen Func für die groß /Kleinschreibung bei regex, welches ich in meinen filter.

private Func<string, BsonRegularExpression> CaseInsensitiveCompare = (field) => 
            BsonRegularExpression.Create(new Regex(field, RegexOptions.IgnoreCase));

Dann filtern Sie einfach auf ein Feld wie folgt.

db.stuff.find({"foo": CaseInsensitiveCompare("bar")}).count();

InformationsquelleAutor der Antwort Nitesh

0

Wie Sie sehen können, in mongo docs - seit der version 3.2 $text index case-insensitive ist standardmäßig: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insensitivity

Erstellen Sie ein text-index und verwenden Sie $text-operator in Ihrer Abfrage.

InformationsquelleAutor der Antwort avalanche1

Diese wurden getestet und für die string-Suche

{'_id': /.*CM.*/}               ||find _id where _id contains   ->CM
{'_id': /^CM/}                  ||find _id where _id starts     ->CM
{'_id': /CM$/}                  ||find _id where _id ends       ->CM

{'_id': /.*UcM075237.*/i}       ||find _id where _id contains   ->UcM075237, ignore upper/lower case
{'_id': /^UcM075237/i}          ||find _id where _id starts     ->UcM075237, ignore upper/lower case
{'_id': /UcM075237$/i}          ||find _id where _id ends       ->UcM075237, ignore upper/lower case

InformationsquelleAutor der Antwort Ar maj

0

Mithilfe der filter funktioniert für mich in C#.
```
string s = "searchTerm";
    var filter = Builders<Model>.Filter.Where(p => p.Title.ToLower().Contains(s.ToLower()));
                var listSorted = collection.Find(filter).ToList();
                var list = collection.Find(filter).ToList();
```
Kann es sogar verwenden Sie den index, weil ich glaube, dass die Methoden aufgerufen werden, die nach der Rückkehr passiert, aber das habe ich noch nicht getestet, heraus noch.

Dies vermeidet auch das problem der
```
var filter = Builders<Model>.Filter.Eq(p => p.Title.ToLower(), s.ToLower());
```
dass mongodb denken p.Titel.ToLower() ist eine Eigenschaft und wird nicht ordnungsgemäß zugeordnet.

InformationsquelleAutor der Antwort A_Arnold

Hatte ich standen vor einem ähnlichen Problem und das ist was für mich gearbeitet:

  const flavorExists = await Flavors.findOne({
    'flavor.name': { $regex: flavorName, $options: 'i' },
  });

InformationsquelleAutor der Antwort Woppi

0

Für die Suche nach einer Variablen und Flucht:
```
const escapeStringRegexp = require('escape-string-regexp')
const name = 'foo'
db.stuff.find({name: new RegExp('^' + escapeStringRegexp(name) + '$', 'i')})   
```
Flucht die variable schützt die Abfrage gegen Angriffe mit '.*' oder andere regex.

escape-string-regexp

InformationsquelleAutor der Antwort davidivad

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.