Como consultar o MongoDB com “like”?

Eu quero consultar algo como consulta do like SQL:

 select * from users where name like '%m%' 

Como fazer o mesmo no MongoDB?
Não consigo encontrar um operador para like nas documentações .

Isso teria que ser:

 db.users.find({"name": /.*m.*/}) 

ou similar:

 db.users.find({"name": /m/}) 

Você está procurando por algo que contenha “m” em algum lugar (o operador ‘ % ‘ do SQL é equivalente ao ‘ .* ‘) Do Regexp, e não algo que tenha “m” ancorado no início da string.

 db.users.insert({name: 'paulo'}) db.users.insert({name: 'patric'}) db.users.insert({name: 'pedro'}) db.users.find({name: /a/}) //like '%a%' 

fora: paulo, patric

 db.users.find({name: /^pa/}) //like 'pa%' 

fora: paulo, patric

 db.users.find({name: /ro$/}) //like '%ro' 

fora: pedro

Dentro

  • PyMongo usando Python
  • Mangusto usando o Node.js
  • Jongo , usando Java
  • mgo , usando Go

você pode fazer:

 db.users.find({'name': {'$regex': 'sometext'}}) 

No PHP, você poderia usar o seguinte código:

 $collection->find(array('name'=> array('$regex' => 'm')); 

Você usaria o regex para isso no mongo.

Por exemplo: db.users.find({"name": /^m/})

Se estiver usando node.js , ele diz que você pode escrever isto:

 db.collection.find( { field: /acme.*corp/i } ); //or db.collection.find( { field: { $regex: 'acme.*corp', $options: 'i' } } ); 

Além disso , você pode escrever isto:

 db.collection.find( { field: new RegExp('acme.*corp', 'i') } ); 

Já existem muitas respostas. Eu estou dando diferentes tipos de requisitos e soluções para pesquisa de strings com regex.

Você pode fazer com regex que contêm palavra ou seja, como. Além disso, você pode usar $options => i para busca insensível a maiúsculas e minúsculas

Contém string

 db.collection.find({name:{'$regex' : 'string', '$options' : 'i'}}) 

Não contém string apenas com regex

 db.collection.find({name:{'$regex' : '^((?!string).)*$', '$options' : 'i'}}) 

string insensível exata

 db.collection.find({name:{'$regex' : '^string$', '$options' : 'i'}}) 

Comece com string

 db.collection.find({name:{'$regex' : '^string', '$options' : 'i'}}) 

Terminar com string

 db.collection.find({name:{'$regex' : 'string$', '$options' : 'i'}}) 

Mantenha isso como um marcador e uma referência para quaisquer outras alterações que você possa precisar.

Você já tem as respostas, mas para combinar regex com insensibilidade a maiúsculas e minúsculas

Você poderia usar a seguinte consulta

 db.users.find ({ "name" : /m/i } ).pretty() 

.pretty() no /m/i indica insensibilidade a maiúsculas e .pretty() fornece uma saída mais bonita

Você tem 2 opções:

 db.users.find({"name": /string/}) 

ou

 db.users.find({"name": {"$regex": "string", "$options": "i"}}) 

No segundo, você tem mais opções, como “i” nas opções para encontrar usando maiúsculas e minúsculas. E sobre a “string”, você pode usar como “. String. ” (% String%), ou “string. *” (String%) e “. * String” (% string) por exemplo. Você pode usar expressão regular como você quiser.

Apreciar!

Para Mongoose em Node.js

 db.users.find({'name': {'$regex': '.*sometext.*'}}) 

Você pode usar o novo recurso do 2.6 mongodb:

 db.foo.insert({desc: "This is a string with text"}); db.foo.insert({desc:"This is a another string with Text"}); db.foo.ensureIndex({"desc":"text"}); db.foo.find({ $text:{ $search:"text" } }); 

Para PHP mongo Como.
Eu tive vários problemas com php mongo como. Descobri que concatenar os params regex ajuda em algumas situações em que o PHP mongo find field começa com . Eu imaginei que eu iria postar aqui para contribuir para o segmento mais popular

por exemplo

 db()->users->insert(['name' => 'john']); db()->users->insert(['name' => 'joe']); db()->users->insert(['name' => 'jason']); // starts with $like_var = 'jo'; $prefix = '/^'; $suffix = '/'; $name = $prefix . $like_var . $suffix; db()->users->find(['name' => array('$regex'=>new MongoRegex($name))]); output: (joe, john) // contains $like_var = 'j'; $prefix = '/'; $suffix = '/'; $name = $prefix . $like_var . $suffix; db()->users->find(['name' => array('$regex'=>new MongoRegex($name))]); output: (joe, john, jason) 

No projeto nodejs e uso mangusto use Like query

 var User = mongoose.model('User'); var searchQuery={}; searchQuery.email = req.query.email; searchQuery.name = {$regex: req.query.name, $options: 'i'}; User.find(searchQuery, function(error, user) { if(error || user === null) { return res.status(500).send(error); } return res.status(200).send(user); }); 

Você pode usar a instrução where para construir qualquer script JS:

 db.myCollection.find( { $where: "this.name.toLowerCase().indexOf('m') >= 0" } ); 

Referência: http://docs.mongodb.org/manual/reference/operator/where/

No SQL, a consulta ‘ like ‘ é assim:

 select * from users where name like '%m%' 

No console do MongoDB, parece com isso:

 db.users.find({"name": /m/}) // Not JSON formatted db.users.find({"name": /m/}).pretty() // JSON formatted 

Além disso, o método pretty() irá em todos os lugares onde produzir a estrutura JSON formatada, que é mais legível.

Use expressões regulares correspondentes conforme abaixo. O ‘i’ mostra insensibilidade ao caso.

 var collections = mongoDatabase.GetCollection("Abcd"); var queryA = Query.And( Query.Matches("strName", new BsonRegularExpression("ABCD", "i")), Query.Matches("strVal", new BsonRegularExpression("4121", "i"))); var queryB = Query.Or( Query.Matches("strName", new BsonRegularExpression("ABCD","i")), Query.Matches("strVal", new BsonRegularExpression("33156", "i"))); var getA = collections.Find(queryA); var getB = collections.Find(queryB); 

Em Go e o driver mgo:

 Collection.Find(bson.M{"name": bson.RegEx{"m", ""}}).All(&result) 

onde result é a instância struct do tipo procurado

Como Query seria como mostrado abaixo

 db.movies.find({title: /.*Twelve Monkeys.*/}).sort({regularizedCorRelation : 1}).limit(10); 

para scala ReactiveMongo api,

 val query = BSONDocument("title" -> BSONRegex(".*"+name+".*", "")) //like val sortQ = BSONDocument("regularizedCorRelation" -> BSONInteger(1)) val cursor = collection.find(query).sort(sortQ).options(QueryOpts().batchSize(10)).cursor[BSONDocument] 

Com o MongoDB Compass, você precisa usar a syntax do modo estrito, como tal:

 { "text": { "$regex": "^Foo.*", "$options": "i" } } 

(No MongoDB Compass, é importante que você use " vez de ' )

Se você estiver usando o Spring-Data Mongodb Você pode fazer isso desta maneira:

 String tagName = "m"; Query query = new Query(); query.limit(10); query.addCriteria(Criteria.where("tagName").regex(tagName)); 

Como o regex de suporte do shell Mongo, isso é completamente possível.

 db.users.findOne({"name" : /.*sometext.*/}); 

Se quisermos que a consulta seja insensível a maiúsculas e minúsculas, podemos usar a opção “i”, como mostrado abaixo:

 db.users.findOne({"name" : /.*sometext.*/i}); 

Se você quiser ‘Curtir’ pesquisa em mongo, então você deve ir com $ regex usando esta consulta será

db.product.find({name:{$regex:/m/i}})

para mais, você pode ler a documentação também. https://docs.mongodb.com/manual/reference/operator/query/regex/

Parece que há razões para usar o padrão javascript /regex_pattern/ bem como o padrão mongo {'$regex': 'regex_pattern'} . Veja: Restrições de Sintaxe RegEx MongoBD

Este não é um tutorial completo do RegEx, mas eu me inspirei a executar esses testes depois de ver um post ambíguo altamente votado acima .

 > ['abbbb','bbabb','bbbba'].forEach(function(v){db.test_collection.insert({val: v})}) > db.test_collection.find({val: /a/}) { "val" : "abbbb" } { "val" : "bbabb" } { "val" : "bbbba" } > db.test_collection.find({val: /.*a.*/}) { "val" : "abbbb" } { "val" : "bbabb" } { "val" : "bbbba" } > db.test_collection.find({val: /.+a.+/}) { "val" : "bbabb" } > db.test_collection.find({val: /^a/}) { "val" : "abbbb" } > db.test_collection.find({val: /a$/}) { "val" : "bbbba" } > db.test_collection.find({val: {'$regex': 'a$'}}) { "val" : "bbbba" } 

Eu encontrei uma ferramenta gratuita para traduzir consultas MYSQL para o MongoDB. http://www.querymongo.com/ Eu verifiquei com várias consultas. como eu vejo quase todos eles estão corretos. De acordo com isso, a resposta é

 db.users.find({ "name": "%m%" }); 

Regex são caros são processos.

Outra maneira é criar um índice de texto e, em seguida, pesquisá-lo usando $search .

Crie um índice de texto dos campos que você deseja tornar pesquisável:

 db.collection.createIndex({name: 'text', otherField: 'text'}); 

Procure uma string no índice de texto:

 db.collection.find({ '$text'=>{'$search': "The string"} }) 

O MongoRegex foi descontinuado.
Use o MongoDB \ BSON \ Regex

 $regex = new MongoDB\BSON\Regex ( '^m'); $cursor = $collection->find(array('users' => $regex)); //iterate through the cursor 

Se você estiver usando PHP, você pode usar o wrapper MongoDB_DataObject como abaixo:

 $model = new MongoDB_DataObject(); $model->query("select * from users where name like '%m%'"); while($model->fetch()) { var_dump($model); } 

OU:

 $model = new MongoDB_DataObject('users); $model->whereAdd("name like '%m%'"); $model->find(); while($model->fetch()) { var_dump($model); } 

FullName como ‘last’ com status == ‘Pending’ entre duas datas:

 db.orders.find({ createdAt:{$gt:ISODate("2017-04-25T10:08:16.111Z"), $lt:ISODate("2017-05-05T10:08:16.111Z")}, status:"Pending", fullName:/last/}).pretty(); 

status == ‘Pending’ e orderId LIKE ‘PHA876174’:

 db.orders.find({ status:"Pending", orderId:/PHA876174/ }).pretty(); 
 db.customer.find({"customerid": {"$regex": "CU_00000*", "$options": "i"}}).pretty() 

Quando estamos procurando por padrões de string, sempre é melhor usar o padrão acima como quando não temos certeza sobre o caso. Espero que ajude!!!

Use pesquisa de substring de agregação (com índice !!!):

 db.collection.aggregate([{ $project : { fieldExists : { $indexOfBytes : ['$field', 'string'] } } }, { $match : { fieldExists : { $gt : -1 } } }, { $limit : 5 } ]);