¿Cómo consultar MongoDB con “me gusta”?

Quiero consultar algo como SQL like consulta:

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

¿Cómo hacer lo mismo en MongoDB?
No puedo encontrar un operador para “me like en la documentación .

Eso debería ser:

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

o similar:

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

Está buscando algo que contenga “m” en alguna parte (el operador ‘ % ‘ de SQL es equivalente a ‘ .* ‘ De Regexp), no algo que tenga una ‘m’ anclada al comienzo de la cadena.

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

fuera: paulo, patric

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

fuera: paulo, patric

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

fuera: pedro

En

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

tu puedes hacer:

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

En PHP, puedes usar el siguiente código:

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

Utilizarías expresiones regulares para eso en mongo.

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

Si usa node.js , dice que puede escribir esto:

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

Además , puedes escribir esto:

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

Ya hay muchas respuestas. Estoy dando diferentes tipos de requisitos y soluciones para la búsqueda de cadenas con expresiones regulares.

Puede hacer con expresiones regulares que contengan palabras, es decir, como. También puede usar $options => i para búsqueda insensible a mayúsculas y minúsculas

Contiene string

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

No contiene string solo con expresiones regulares

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

string exacta insensible a mayúsculas y minúsculas

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

Comience con una string

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

Terminar con una string

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

Mantenga esto como un marcador y una referencia para cualquier otra alteración que pueda necesitar.

Ya tienes las respuestas, pero para que coincida con la expresión regular con insensibilidad de mayúsculas y minúsculas

Puedes usar la siguiente consulta

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

El i en /m/i indica insensibilidad a mayúsculas y minúsculas y .pretty() proporciona una salida más bonita

Tienes 2 opciones:

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

o

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

En el segundo, tienes más opciones, como “i” en las opciones para encontrar el uso de mayúsculas y minúsculas. Y sobre la “cadena”, puede usar como ” .cadena. (% Cadena%), o “cadena. *” (Cadena%) y “. * Cadena) (% cadena) por ejemplo. Puede usar expresión regular como quieras

¡Disfrutar!

Para Mongoose en Node.js

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

Puede usar la nueva característica de 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 Like.
Tuve varios problemas con php mongo. encontré que concatenar los parámetros de expresiones regulares ayuda en algunas situaciones en que comienza el campo de búsqueda de PHP mongo . Pensé que publicaría aquí para contribuir al hilo más popular

p.ej

 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) 

En proyecto nodejs y uso de mongoose Como consulta

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

Puede usar la sentencia where para comstackr cualquier script JS:

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

Referencia: http://docs.mongodb.org/manual/reference/operator/where/

En SQL, la consulta ‘me gusta ‘ es así:

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

En la consola MongoDB, se ve así:

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

En addion, el método pretty() en todos los lugares donde se produce una estructura JSON formateada que es más legible.

Use la coincidencia de expresiones regulares como a continuación. La ‘i’ muestra insensibilidad a mayúsculas y minúsculas.

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

En Go y el controlador mgo:

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

donde result es la instancia struct del tipo buscado

Like Query sería como se muestra a continuación

 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] 

Con MongoDB Compass, debe usar la syntax del modo estricto, como tal:

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

(En MongoDB Compass, es importante que use " lugar de ' )

Si está utilizando Spring-Data Mongodb, puede hacerlo de esta manera:

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

Como Mongo shell support regex, eso es completamente posible.

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

Si queremos que la consulta no distinga entre mayúsculas y minúsculas, podemos usar la opción “i”, como se muestra a continuación:

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

Si desea buscar ‘Me gusta’ en mongo, debe ir con $ regex al usar esta consulta.

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

para más información, puede leer la documentación también. https://docs.mongodb.com/manual/reference/operator/query/regex/

Parece que hay razones para usar tanto el patrón javascript /regex_pattern/ pattern como el patrón mongo {'$regex': 'regex_pattern'} . Ver: Restricciones de syntax RegEx de MongoBD

Este no es un tutorial completo de RegEx, pero me inspiré para ejecutar estas pruebas después de ver una publicación ambigua altamente votada arriba .

 > ['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" } 

Encontré una herramienta gratuita para traducir las consultas MYSQL a MongoDB. http://www.querymongo.com/ Comprobé con varias consultas. como veo casi todos ellos son correctos. Según eso, la respuesta es

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

Regex son costosos son proceso.

Otra forma es crear un índice de texto y luego buscarlo usando $search .

Crear un texto Índice de campos que desea que se puedan buscar:

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

Busque una cadena en el índice de texto:

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

MongoRegex ha quedado obsoleto.
Utilice MongoDB \ BSON \ Regex

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

Si está utilizando PHP, puede usar el contenedor MongoDB_DataObject como se muestra a continuación:

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

O:

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

FullName como ‘last’ con estado == ‘Pendiente’ entre dos fechas:

 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(); 

estado == ‘Pendiente’ y orderId LIKE ‘PHA876174’:

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

Cuando buscamos patrones de cuerda, siempre es mejor usar el patrón anterior como cuando no estamos seguros sobre el caso. ¡¡¡Espero que ayude!!!

Utilice la búsqueda de subcadenas de agregación (con índice !!!):

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