Esempio:

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

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

Potresti usare una regex .

Nel tuo esempio sarebbe:

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

Devo dire, però, che potresti semplicemente ridurre (o aumentare) il valore lungo il percorso piuttosto che sostenere il costo aggiuntivo ogni volta che lo trovi. Ovviamente questo non funzionerà per i nomi delle persone e simili, ma forse casi d'uso come tag.

AGGIORNARE:

La risposta originale è ora obsoleta. Mongodb ora supporta la ricerca avanzata full-text, con molte funzionalità.

RISPOSTA ORIGINALE:

Va notato che la ricerca con maiuscole / minuscole regex significa che mongodb non può cercare per indice, quindi le query su insiemi di dati di grandi dimensioni possono richiedere molto tempo.

Anche con piccoli set di dati, non è molto efficiente. Prendi un hit cpu molto più grande dei tuoi quesiti, il che potrebbe diventare un problema se stai cercando di raggiungere la scala.

In alternativa, puoi archiviare una copia maiuscola e cercare in quella direzione. Ad esempio, ho una tabella utente con un nome utente che è un caso misto, ma l'id è una copia maiuscola del nome utente. Questo assicura che la duplicazione con distinzione tra maiuscole e minuscole sia impossibile (non saranno consentiti sia "Foo" che "foo"), e posso cercare per id = username.toUpperCase () per ottenere una ricerca senza distinzione tra maiuscole e minuscole per il nome utente.

Se il tuo campo è grande, come un corpo di messaggio, la duplicazione dei dati probabilmente non è una buona opzione. Credo che usare un indicizzatore estraneo come Apache Lucene sia l'opzione migliore in quel caso.

Se devi creare il regexp da una variabile, questo è un modo molto migliore per farlo: https://stackoverflow.com/a/10728069/309514

Puoi quindi fare qualcosa del tipo:

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

Questo ha il vantaggio di essere più programmatico o puoi ottenere un aumento delle prestazioni compilandolo in anticipo se lo stai riutilizzando molto.

Tieni presente che l'esempio precedente:

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

farà sì che ogni voce contenente la barra corrisponda alla query (bar1, barxyz, openbar), potrebbe essere molto pericoloso per una ricerca nome utente su una funzione di autenticazione ...

Potrebbe essere necessario farlo corrispondere solo al termine di ricerca utilizzando la sintassi regexp appropriata come:

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

Vedi http://www.regular-expressions.info/ per aiuto sulla sintassi delle espressioni regolari

A partire da MongoDB 3.4, il modo consigliato per eseguire ricerche veloci senza distinzione tra maiuscole e minuscole è utilizzare un indice insensibile alle maiuscole .

Ho mandato personalmente uno dei fondatori per favore per far funzionare tutto questo, e l'ha fatto accadere! È stato un problema su JIRA dal 2009 e molti hanno richiesto la funzione. Ecco come funziona:

Un indice senza distinzione tra maiuscole e minuscole viene creato specificando una fascicolazione con un valore di 1 o 2. È possibile creare un indice senza distinzione tra maiuscole e minuscole in questo modo:

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

Puoi anche specificare un confronto predefinito per raccolta quando li crei:

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

In entrambi i casi, per utilizzare l'indice senza distinzione tra maiuscole e minuscole, è necessario specificare le stesse regole di confronto findnell'operazione utilizzata durante la creazione dell'indice o della raccolta:

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

Ciò restituirà "New York", "New York", "New York" ecc.

Altre note

• Le risposte che suggeriscono di utilizzare la ricerca full-text sono errate in questo caso (e potenzialmente pericolose ). La domanda riguardava la creazione di una query senza distinzione tra maiuscole e minuscole, ad esempio la username: 'bill'corrispondenza BILLo Bill, non una query di ricerca full-text, che corrisponderebbe anche a parole derivatebill , come Bills, billedecc.

• Le risposte che suggeriscono di usare espressioni regolari sono lente, perché anche con gli indici, la documentazione afferma :

  "Le query con espressioni regolari senza distinzione tra maiuscole e minuscole in genere non possono utilizzare gli indici in modo efficace. L'implementazione di $ regex non è sensibile alle regole di confronto e non è in grado di utilizzare indici senza distinzione tra maiuscole e minuscole."

  $regexle risposte corrono anche il rischio di iniezione da parte dell'utente .

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

TL; DR

Modo corretto per farlo in mongo

Non utilizzare RegExp

Diventa naturale E usa l'indicizzazione integrata di mongodb, cerca

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

Passo 2 :

È necessario creare un indice su qualsiasi campo TEXT che si desidera cercare, senza che la query di indicizzazione sia estremamente lenta

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

passaggio 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 (versione corrente 2.0.0) non consente ricerche senza distinzione tra maiuscole e minuscole rispetto ai campi indicizzati: consulta la loro documentazione . Per i campi non indicizzati, le regex elencate nelle altre risposte dovrebbero andare bene.

Una cosa molto importante da tenere a mente quando si utilizza una query basata su Regex: quando si esegue questa operazione per un sistema di accesso, sfuggire a ogni singolo carattere che si sta cercando e non dimenticare gli operatori ^ e $. Lodash ha una bella funzione per questo , se lo stai già usando:

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

Perché? Immagina un utente che entra .*come suo nome utente. Ciò corrisponderebbe a tutti i nomi utente, abilitando un accesso semplicemente indovinando la password di qualsiasi utente.

Il metodo migliore è nella tua lingua preferita, quando crei un wrapper modello per i tuoi oggetti, fai in modo che il tuo metodo save () esegua l'iterazione attraverso una serie di campi su cui stai cercando che sono anche indicizzati; tali set di campi devono avere controparti minuscole che vengono quindi utilizzate per la ricerca.

Ogni volta che l'oggetto viene nuovamente salvato, le proprietà minuscole vengono quindi controllate e aggiornate con eventuali modifiche alle proprietà principali. Ciò consentirà di effettuare ricerche in modo efficiente, ma di nascondere il lavoro aggiuntivo necessario per aggiornare i campi LC ogni volta.

I campi minuscoli potrebbero essere una chiave: valore oggetto archivio o solo il nome del campo con un prefisso lc_. Uso il secondo per semplificare l'interrogazione (a volte l'interrogazione di oggetti profondi può creare confusione).

Nota: si desidera indicizzare i campi lc_, non i campi principali su cui sono basati.

Supponiamo di voler cercare "colonna" in "Tabella" e di cercare la ricerca senza distinzione tra maiuscole e minuscole. Il modo migliore ed efficiente è il seguente;

//create empty JSON Object
mycolumn = {};

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

Il codice sopra aggiunge semplicemente il valore di ricerca come RegEx e cerca con criteri insensibili impostati con "i" come opzione.

Ti auguro il meglio.

Usando Mongoose ha funzionato per me:

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

Il framework di aggregazione è stato introdotto in mongodb 2.2. È possibile utilizzare l'operatore di stringa "$ strcasecmp" per effettuare un confronto senza distinzione tra maiuscole e minuscole. È più consigliato e più semplice rispetto all'utilizzo di regex.

Ecco il documento ufficiale sull'operatore del comando di aggregazione: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp .

È possibile utilizzare gli indici insensibili alle maiuscole :

L'esempio seguente crea una raccolta senza regole di confronto predefinite, quindi aggiunge un indice sul campo del nome con regole di confronto senza distinzione tra maiuscole e minuscole. Componenti internazionali per 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 } } )

Per utilizzare l'indice, le query devono specificare le stesse regole di confronto.

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

oppure puoi creare una raccolta con regole di confronto predefinite:

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

Per cercare una variabile e sfuggirla:

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

L'escape della variabile protegge la query dagli attacchi con '. *' O altri regex.

fuga-string-regexp

Usa RegExp , nel caso in cui qualsiasi altra opzione non funzioni per te, RegExp è una buona opzione. Rende la distinzione tra maiuscole e minuscole.

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

usa il nome utente nelle query e poi è fatto.

Spero che funzionerà anche per te. Ti auguro il meglio.

Ho creato un semplice Func per il regex insensibile al maiuscolo / minuscolo, che uso nel mio filtro.

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

Quindi si filtra semplicemente su un campo come segue.

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

L'uso di un filtro funziona per me 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();

Potrebbe persino utilizzare l'indice perché credo che i metodi vengano chiamati dopo che si è verificato il ritorno, ma non l'ho ancora testato.

Questo evita anche un problema di

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

quel mongodb penserà che p.Title.ToLower () sia una proprietà e non verrà mappata correttamente.

Per chiunque utilizzi Golang e desidera avere la ricerca di testo completo maiuscole e minuscole con mongodb e la libreria mgo godoc globalsign .

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


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

Come puoi vedere nei documenti di mongo, poiché l' $textindice della versione 3.2 non fa distinzione tra maiuscole e minuscole per impostazione predefinita: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insensitivity

Crea un indice di testo e usa $ text operator nella tua query .

Questi sono stati testati per le ricerche di stringhe

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

Avevo affrontato un problema simile e questo è ciò che ha funzionato per me:

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