Beispiel:

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

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

Sie könnten einen regulären Ausdruck verwenden .

In Ihrem Beispiel wäre das:

db.stuff.find( { foo: /^bar$/i } );

Ich muss jedoch sagen, dass Sie den Wert auf dem Weg dorthin möglicherweise nur in Kleinbuchstaben (oder Großbuchstaben) umwandeln können, anstatt jedes Mal, wenn Sie ihn finden, die zusätzlichen Kosten zu verursachen. Offensichtlich funktioniert dies nicht für die Namen von Personen und dergleichen, aber möglicherweise für Anwendungsfälle wie Tags.

AKTUALISIEREN:

Die ursprüngliche Antwort ist jetzt veraltet. Mongodb unterstützt jetzt die erweiterte Volltextsuche mit vielen Funktionen.

URSPRÜNGLICHE ANTWORT:

Es sollte beachtet werden, dass das Suchen mit der Groß- und Kleinschreibung von Regex / i bedeutet, dass Mongodb nicht nach Index suchen kann, sodass Abfragen für große Datenmengen lange dauern können.

Selbst mit kleinen Datensätzen ist es nicht sehr effizient. Sie erzielen einen weitaus größeren CPU-Treffer als Ihre Abfragebefehle, was zu einem Problem werden kann, wenn Sie versuchen, eine Skalierung zu erreichen.

Alternativ können Sie eine Kopie in Großbuchstaben speichern und danach suchen. Zum Beispiel habe ich eine Benutzertabelle mit einem Benutzernamen, der in Groß- und Kleinschreibung geschrieben ist, aber die ID ist eine Kopie des Benutzernamens in Großbuchstaben. Dies stellt sicher, dass eine Duplizierung ohne Berücksichtigung der Groß- und Kleinschreibung nicht möglich ist (sowohl "Foo" als auch "foo" sind nicht zulässig), und ich kann nach id = username.toUpperCase () suchen, um eine Suche nach Benutzernamen ohne Berücksichtigung der Groß- und Kleinschreibung zu erhalten.

Wenn Ihr Feld groß ist, z. B. ein Nachrichtentext, ist das Duplizieren von Daten wahrscheinlich keine gute Option. Ich glaube, dass die Verwendung eines externen Indexers wie Apache Lucene in diesem Fall die beste Option ist.

Wenn Sie den regulären Ausdruck aus einer Variablen erstellen müssen, ist dies eine viel bessere Möglichkeit: https://stackoverflow.com/a/10728069/309514

Sie können dann so etwas tun 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 es programmatischer ist oder Sie eine Leistungssteigerung erzielen können, indem Sie es im Voraus kompilieren, wenn Sie es häufig wiederverwenden.

Beachten Sie, dass das vorherige Beispiel:

db.stuff.find( { foo: /bar/i } );

Wenn alle Einträge, die bar enthalten , mit der Abfrage übereinstimmen (bar1, barxyz, openbar), kann dies für eine Suche nach Benutzernamen in einer Authentifizierungsfunktion sehr gefährlich sein ...

Möglicherweise müssen Sie festlegen, dass es nur mit dem Suchbegriff übereinstimmt, indem Sie die entsprechende Regexp-Syntax wie folgt verwenden:

db.stuff.find( { foo: /^bar$/i } );

Unter http://www.regular-expressions.info/ finden Sie Syntaxhilfen für reguläre Ausdrücke

Ab MongoDB 3.4 wird empfohlen, einen schnellen Index ohne Berücksichtigung der Groß- und Kleinschreibung zu verwenden, um eine schnelle Suche ohne Berücksichtigung der Groß- und Kleinschreibung durchzuführen .

Ich habe persönlich einen der Gründer per E-Mail benachrichtigt, damit dies funktioniert, und er hat es möglich gemacht! Es war seit 2009 ein Problem bei JIRA , und viele haben die Funktion angefordert. So funktioniert das:

Ein Index ohne Berücksichtigung der Groß- und Kleinschreibung wird erstellt, indem eine Kollatierung mit einer Stärke von 1 oder 2 angegeben wird. Sie können einen Index ohne Berücksichtigung der Groß- und Kleinschreibung wie folgt erstellen:

db.cities.createIndex(
  { city: 1 },
  { 
    collation: {
      locale: 'en',
      strength: 2
    }
  }
);

Sie können beim Erstellen auch eine Standardkollatierung pro Sammlung angeben:

db.createCollection('cities', { collation: { locale: 'en', strength: 2 } } );

In beiden Fällen müssen Sie zur Verwendung des Index ohne Berücksichtigung der Groß- und Kleinschreibung dieselbe Sortierung in der findOperation angeben , die beim Erstellen des Index oder der Auflistung verwendet wurde:

db.cities.find(
  { city: 'new york' }
).collation(
  { locale: 'en', strength: 2 }
);

Dies gibt "New York", "New York", "New York" usw. zurück.

Weitere Hinweise

• Die Antworten, die eine Volltextsuche vorschlagen, sind in diesem Fall falsch (und möglicherweise gefährlich ). Die Frage war , über eine Fall unempfindliche Abfrage machen, zB username: 'bill'passenden BILLoder Billnicht eine Volltextsuchabfrage, die auch Spiel würde stammten Worte billwie Bills, billedusw.

• Die Antworten, die die Verwendung regulärer Ausdrücke vorschlagen, sind langsam, da in der Dokumentation selbst bei Indizes Folgendes angegeben ist :

  "Abfragen für reguläre Ausdrücke, bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird, können Indizes im Allgemeinen nicht effektiv verwenden. Die Implementierung von $ regex ist nicht kollationsbewusst und kann keine Indizes verwenden, bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird."

  $regexAntworten bergen auch das Risiko einer Benutzereingabe .

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

TL; DR

Richtiger Weg, dies in Mongo zu tun

Verwenden Sie RegExp nicht

Gehen Sie natürlich und verwenden Sie Mongodbs eingebaute Indizierung, suchen Sie

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 :

Sie müssen einen Index für jedes TEXT- Feld erstellen, das Sie durchsuchen möchten, ohne dass die Abfrage indiziert wird. Dies ist äußerst 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

db.company_profile.find({ "companyName" : { "$regex" : "Nilesh" , "$options" : "i"}});

Mongo (aktuelle Version 2.0.0) erlaubt keine Suche ohne Berücksichtigung der Groß- und Kleinschreibung für indizierte Felder - siehe deren Dokumentation . Für nicht indizierte Felder sollten die in den anderen Antworten aufgeführten regulären Ausdrücke in Ordnung sein.

Eine sehr wichtige Sache, die Sie bei der Verwendung einer Regex-basierten Abfrage beachten sollten: Wenn Sie dies für ein Anmeldesystem tun, maskieren Sie jedes einzelne gesuchte Zeichen und vergessen Sie die Operatoren ^ und $ nicht. Lodash hat eine nette Funktion dafür , falls Sie es bereits verwenden:

db.stuff.find({$regex: new RegExp(_.escapeRegExp(bar), $options: 'i'})

Warum? Stellen Sie sich einen Benutzer vor, .*der seinen Benutzernamen eingibt. Das würde mit allen Benutzernamen übereinstimmen und eine Anmeldung ermöglichen, indem nur das Passwort eines Benutzers erraten wird.

Die beste Methode ist in der Sprache Ihrer Wahl. Wenn Sie einen Modell-Wrapper für Ihre Objekte erstellen, lassen Sie Ihre save () -Methode eine Reihe von Feldern durchlaufen, nach denen Sie suchen und die ebenfalls indiziert sind. Diese Felder sollten Gegenstücke in Kleinbuchstaben enthalten, die dann für die Suche verwendet werden.

Jedes Mal, wenn das Objekt erneut gespeichert wird, werden die Eigenschaften in Kleinbuchstaben überprüft und mit Änderungen an den Haupteigenschaften aktualisiert. Auf diese Weise können Sie effizient suchen, aber die zusätzliche Arbeit, die zum Aktualisieren der lc-Felder jedes Mal erforderlich ist, verbergen.

Die Felder in Kleinbuchstaben können ein Schlüssel sein: Wert Objektspeicher oder nur der Feldname mit dem Präfix lc_. Ich verwende die zweite, um die Abfrage zu vereinfachen (tiefe Objektabfragen können manchmal verwirrend sein).

Hinweis: Sie möchten die lc_-Felder indizieren, nicht die Hauptfelder, auf denen sie basieren.

Angenommen, Sie möchten "Spalte" in "Tabelle" suchen und möchten eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung durchführen. Der beste und effizienteste Weg ist wie folgt;

//create empty JSON Object
mycolumn = {};

//check if column has valid value
if(column) {
    mycolumn.column = {$regex: new RegExp(column), $options: "i"};
}
Table.find(mycolumn);

Der obige Code fügt nur Ihren Suchwert als RegEx hinzu und sucht mit unempfindlichen Kriterien, die mit "i" als Option festgelegt sind.

Alles Gute.

Mit Mongoose hat das bei mir funktioniert:

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

Das Aggregations-Framework wurde in Mongodb 2.2 eingeführt. Sie können den Zeichenfolgenoperator "$ strcasecmp" verwenden, um einen Vergleich zwischen Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung durchzuführen. Es ist empfehlenswerter und einfacher als die Verwendung von Regex.

Hier ist das offizielle Dokument zum Aggregationsbefehlsoperator: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp .

Sie können Indizes verwenden, bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird :

Im folgenden Beispiel wird eine Sammlung ohne Standardkollatierung erstellt und anschließend ein Index für das Namensfeld mit einer Sortierung hinzugefügt, bei der die Groß- und Kleinschreibung nicht berücksichtigt wird. 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 } } )

Um den Index verwenden zu können, müssen Abfragen dieselbe Sortierung angeben.

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 Sie können eine Sammlung mit Standardkollatierung erstellen:

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

Zum Suchen und Entkommen einer Variablen:

const escapeStringRegexp = require('escape-string-regexp')
const name = 'foo'
db.stuff.find({name: new RegExp('^' + escapeStringRegexp(name) + '$', 'i')})   

Das Escaping der Variablen schützt die Abfrage vor Angriffen mit '. *' Oder einem anderen regulären Ausdruck.

Escape-String-Regexp

Verwenden Sie RegExp . Falls andere Optionen für Sie nicht funktionieren, ist RegExp eine gute Option. Dadurch wird die Groß- und Kleinschreibung der Zeichenfolge nicht berücksichtigt.

var username = new RegExp("^" + "John" + "$", "i");;

Verwenden Sie den Benutzernamen in Abfragen, und dann ist es fertig.

Ich hoffe es wird auch für dich funktionieren. Alles Gute.

Ich habe eine einfache Funktion für die Groß- und Kleinschreibung erstellt, die ich in meinem Filter verwende.

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

Dann filtern Sie einfach wie folgt nach einem Feld.

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

Die Verwendung eines Filters funktioniert bei mir 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();

Möglicherweise wird sogar der Index verwendet, da ich glaube, dass die Methoden nach der Rückgabe aufgerufen werden, aber ich habe dies noch nicht getestet.

Dies vermeidet auch ein Problem von

var filter = Builders<Model>.Filter.Eq(p => p.Title.ToLower(), s.ToLower());

Dieser Mongodb wird denken, dass p.Title.ToLower () eine Eigenschaft ist und nicht richtig zugeordnet wird.

Für alle, die Golang verwenden und eine Volltextsuche mit Groß- und Kleinschreibung mit mongodb und der mgo godoc globalsign Bibliothek wünschen .

collation := &mgo.Collation{
    Locale:   "en",
    Strength: 2, 
}


err := collection.Find(query).Collation(collation)

Wie Sie in Mongo-Dokumenten sehen können - da der $textIndex der Version 3.2 standardmäßig nicht zwischen Groß- und Kleinschreibung unterscheidet: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insensitivity

Erstellen Sie einen Textindex und verwenden Sie den $ text-Operator in Ihrer Abfrage .

Diese wurden für die Suche nach Zeichenfolgen getestet

{'_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

Ich hatte ein ähnliches Problem und das hat bei mir funktioniert:

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