Przykład:

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

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

Możesz użyć wyrażenia regularnego .

W twoim przykładzie byłoby to:

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

Muszę jednak powiedzieć, że może po prostu zmniejszysz wartość (lub zwiększysz) wartość po drodze, zamiast ponosić dodatkowy koszt za każdym razem, gdy ją znajdziesz. Oczywiście nie zadziała to w przypadku nazwisk osób i tym podobnych, ale może przypadków użycia takich jak tagi.

AKTUALIZACJA:

Oryginalna odpowiedź jest już nieaktualna. Mongodb obsługuje teraz zaawansowane wyszukiwanie pełnotekstowe z wieloma funkcjami.

ORYGINALNA ODPOWIEDŹ:

Należy zauważyć, że wyszukiwanie z rozróżnianiem wielkości liter w wyrażeniach regularnych / i oznacza, że ​​mongodb nie może wyszukiwać według indeksu, więc zapytania do dużych zestawów danych mogą zająć dużo czasu.

Nawet przy małych zestawach danych nie jest to zbyt wydajne. Przyjmujesz znacznie większą moc procesora niż twoje zapytanie, co może stać się problemem, jeśli próbujesz osiągnąć skalę.

Alternatywnie możesz przechowywać wielką kopię i wyszukiwać według niej. Na przykład mam tabelę użytkowników, która ma nazwę użytkownika, która jest wielkimi literami, ale identyfikator jest wielką literą nazwy użytkownika. Zapewnia to, że powielanie z rozróżnianiem wielkości liter jest niemożliwe (nie można zarówno używać „Foo”, jak i „foo”), i mogę wyszukiwać według id = nazwa_użytkownika.toUpperCase (), aby uzyskać wyszukiwanie nazwy użytkownika bez rozróżniania wielkości liter.

Jeśli twoje pole jest duże, na przykład treść wiadomości, powielanie danych prawdopodobnie nie jest dobrym rozwiązaniem. Uważam, że użycie zewnętrznego indeksatora, takiego jak Apache Lucene, jest najlepszą opcją w tym przypadku.

Jeśli chcesz utworzyć wyrażenie regularne ze zmiennej, jest to o wiele lepszy sposób: https://stackoverflow.com/a/10728069/309514

Następnie możesz zrobić coś takiego:

var string = "SomeStringToFind";
var regex = new RegExp(["^", string, "$"].join(""), "i");
// Creates a regex of: /^SomeStringToFind$/i
db.stuff.find( { foo: regex } );

Ma to tę zaletę, że jest bardziej programowy lub możesz zwiększyć wydajność, kompilując go wcześniej, jeśli często go używasz.

Pamiętaj, że poprzedni przykład:

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

spowoduje, że wszystkie wpisy zawierające pasek będą pasować do zapytania (bar1, barxyz, openbar), może być bardzo niebezpieczne dla wyszukiwania nazwy użytkownika w funkcji auth ...

Może być konieczne dopasowanie go tylko do wyszukiwanego hasła przy użyciu odpowiedniej składni wyrażenia regularnego jako:

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

Zobacz http://www.regular-expressions.info/, aby uzyskać pomoc dotyczącą składni wyrażeń regularnych

Począwszy od MongoDB 3.4, zalecanym sposobem szybkiego wyszukiwania bez rozróżniania wielkości liter jest użycie indeksu bez rozróżniania wielkości liter .

Osobiście wysłałem e-maila do jednego z założycieli, aby ten działał, a on to sprawił! To był problem na JIRA od 2009 roku i wielu poprosiło o tę funkcję. Oto jak to działa:

Indeks bez rozróżniania wielkości liter jest tworzony przez określenie sortowania o sile 1 lub 2. Można utworzyć indeks bez rozróżniania wielkości liter, jak poniżej:

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

Możesz także określić domyślne sortowanie dla kolekcji podczas ich tworzenia:

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

W obu przypadkach, aby użyć indeksu bez rozróżniania wielkości liter, musisz określić to samo sortowanie w findoperacji, która była używana podczas tworzenia indeksu lub kolekcji:

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

Zwróci „Nowy Jork”, „Nowy Jork”, „Nowy Jork” itp.

Inne notatki

• Odpowiedzi sugerujące użycie wyszukiwania pełnotekstowego są w tym przypadku błędne (i potencjalnie niebezpieczne ). Pytanie dotyczyło rozróżnienia wielkości liter, npusername: 'bill' dopasowanie BILLlub Bill, a nie kwerendy wyszukiwanie pełnotekstowe, które również mecz wynikała słowa bill, takie jak Bills, billedetc.

• Odpowiedzi sugerujące użycie wyrażeń regularnych są powolne, ponieważ nawet przy indeksach dokumentacja stwierdza :

  „Kwerendy wyrażeń regularnych bez rozróżniania wielkości liter na ogół nie mogą skutecznie korzystać z indeksów. Implementacja $ regex nie rozpoznaje sortowania i nie może korzystać z indeksów bez rozróżniania wielkości liter.”

  $regexodpowiedzi również narażają na ryzyko wprowadzenia danych przez użytkownika .

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

TL; DR

Prawidłowy sposób na zrobienie tego w mongo

Nie używaj RegExp

Stań się naturalny I użyj wbudowanego indeksowania mongodb, szukaj

Krok 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 }
   ]
)

Krok 2 :

Musisz utworzyć indeks w dowolnym polu tekstowym, które chcesz przeszukać, bez zapytania o indeksowanie będzie to bardzo powolne

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

krok 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 (aktualna wersja 2.0.0) nie zezwala na wyszukiwanie bez rozróżniania wielkości liter względem indeksowanych pól - zobacz ich dokumentację . W przypadku pól nieindeksowanych wyrażenia regularne wymienione w innych odpowiedziach powinny być w porządku.

Podczas korzystania z zapytania opartego na Regex należy pamiętać o jednej bardzo ważnej rzeczy - robiąc to dla systemu logowania, unikaj każdego szukanego znaku i nie zapomnij o operatorach ^ i $. Lodash ma do tego przyjemną funkcję , jeśli już z niej korzystasz:

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

Dlaczego? Wyobraź sobie użytkownika wprowadzającego się .*jako jego nazwa użytkownika. To by pasowało do wszystkich nazw użytkowników, umożliwiając logowanie po prostu odgadując hasło dowolnego użytkownika.

Najlepsza metoda jest w wybranym języku, podczas tworzenia opakowania modelu dla twoich obiektów, niech twoja metoda save () iteruje przez zestaw pól, które będziesz przeszukiwał i które są również indeksowane; zestaw pól powinien zawierać małe litery, które są następnie używane do wyszukiwania.

Za każdym razem, gdy obiekt jest zapisywany, właściwości małych liter są następnie sprawdzane i aktualizowane o wszelkie zmiany w głównych właściwościach. To sprawi, że będziesz mógł efektywnie wyszukiwać, ale ukryjesz dodatkową pracę potrzebną do aktualizacji pól lc za każdym razem.

Pola pisane małymi literami mogą być kluczem: składnicą wartości obiektu lub po prostu nazwą pola z prefiksem lc_. Korzystam z drugiego, aby uprościć tworzenie zapytań (zapytania do obiektów głębokich mogą być czasami mylące).

Uwaga: chcesz zindeksować pola lc_, a nie główne pola, na których są oparte.

Załóżmy, że chcesz wyszukać „kolumnę” w „Tabeli” i chcesz wyszukiwać bez rozróżniania wielkości liter. Najlepszy i skuteczny sposób jest taki jak poniżej;

//create empty JSON Object
mycolumn = {};

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

Powyższy kod po prostu dodaje wartość wyszukiwania jako RegEx i wyszukuje według niewrażliwych kryteriów ustawionych z opcją „i”.

Wszystkiego najlepszego.

Przy użyciu Mongoose to działało dla mnie:

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

Ramy agregacji zostały wprowadzone w mongodb 2.2. Możesz użyć operatora łańcuchowego „$ strcasecmp”, aby rozróżnić ciągi znaków bez rozróżniania wielkości liter. Jest to bardziej zalecane i łatwiejsze niż użycie wyrażenia regularnego.

Oto oficjalny dokument dotyczący operatora polecenia agregacji: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp .

Możesz użyć indeksów bez rozróżniania wielkości liter :

Poniższy przykład tworzy kolekcję bez domyślnego sortowania, a następnie dodaje indeks do pola nazwy z sortowaniem bez rozróżniania wielkości liter. Międzynarodowe komponenty dla 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 } } )

Aby użyć indeksu, zapytania muszą określać to samo sortowanie.

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 } )

lub możesz utworzyć kolekcję z domyślnym zestawieniem:

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

Aby wyszukać zmienną i uciec od niej:

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

Zmiana znaczenia chroni kwerendę przed atakami za pomocą „. *” Lub innego wyrażenia regularnego.

wyrażenie-łańcuchowe-wyrażenie-regularne

Użyj RegExp , w przypadku, gdy jakiekolwiek inne opcje nie działają dla Ciebie, RegExp jest dobrą opcją. Powoduje to, że ciąg nie rozróżnia wielkości liter.

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

użyj nazwy użytkownika w zapytaniach, a następnie gotowe.

Mam nadzieję, że to również zadziała dla ciebie. Wszystkiego najlepszego.

Stworzyłem prosty Func dla wyrażenia regularnego bez rozróżniania wielkości liter, którego używam w moim filtrze.

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

Następnie po prostu filtruj według pola w następujący sposób.

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

Użycie filtra działa dla mnie w 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();

Może nawet użyć indeksu, ponieważ uważam, że metody są wywoływane po powrocie, ale jeszcze tego nie przetestowałem.

Pozwala to również uniknąć problemu

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

ten mongodb uzna, że ​​p.Title.ToLower () jest właściwością i nie będzie poprawnie mapowany.

Dla każdego, kto używa Golanga i chce mieć rozróżnianie wielkości liter w wyszukiwaniu pełnotekstowym za pomocą mongodb i biblioteki globalsign mgo godoc .

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


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

Jak widać w dokumentach mongo - ponieważ $textindeks wersji 3.2 domyślnie nie rozróżnia wielkości liter: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insenssens

Utwórz indeks tekstowy i użyj operatora $ text w zapytaniu .

Zostały one przetestowane pod kątem wyszukiwania ciągów

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

Miałem do czynienia z podobnym problemem i właśnie to działało dla mnie:

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