Cómo consultar MongoDB con "me gusta"?

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
• Mangostausando el nodo .js
• Jongo , usando Java
• mgo , usando Go

Puedes hacer:

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

En PHP, puedes usar el siguiente código:

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

Usarías expresiones regulares para eso en mongo.

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

Si se usa el nodo .js, dice que puedes escribir esto:

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

También, 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.

Se puede hacer con expresiones regulares que contienen la palabra es decir, como. También se puede utilizar $options => i para la 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'}})

Insensible a mayúsculas y minúsculas string

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

Comienza con string

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

Termina con 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.

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 opciones para encontrar usando mayúsculas y minúsculas. Y sobre la "cadena", puedes usar como ".cadena. " (%string%), o "string.* "(string%) and ".* string) (%string) por ejemplo. Puede usar expresiones regulares como desee.

Disfrute!

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

Puede utilizar la siguiente consulta

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

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

Para Mangosta en Nodo.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 como. descubrí que concatenar los parámetros regex ayuda en algunas situaciones El campo PHP mongo find comienza con . Pensé que publicaría aquí para contribuir al hilo más popular

E. g

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)

In nodejs project and use mongoose 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);
            });

Puede usar la instrucción where para construir 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' like ' se ve 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

In addion pretty() método en todos los lugares donde producir estructura JSON formateada que es más legible.

Utilice expresiones regulares que coincidan como se muestra a continuación. La' i ' muestra insensibilidad a las 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 de estructura del tipo buscado

Como consulta 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, necesita usar la sintaxis de modo estricto, como tal:

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

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

Si está utilizando Spring-Data Mongodb Puede hacer esto de esta manera:

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

Como el shell de Mongo soporta regex, eso es completamente posible.

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

Si queremos que la consulta sea insensible a mayúsculas y minúsculas, podemos usar la opción "i", como se muestra a continuación:

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

Si quieres' Me gusta ' buscar en mongo entonces usted debe ir con reg regex mediante el uso de esta consulta será

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/ como el patrón mongo {'$regex': 'regex_pattern'}. Ver: Restricciones de sintaxis REGEX de MongoBD

Este no es un tutorial de expresiones REGULARES completo, pero me inspiré para ejecutar estas pruebas después de ver un altamente votado mensaje ambiguo por encima de.

> ['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 consultas MYSQL a MongoDB. http://www.querymongo.com / Comprobé con varias consultas. como veo, casi todas son correctas. De acuerdo con 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.

Cree un índice de texto de los campos que desea que se puedan buscar:

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

Buscar una cadena en el índice de texto:

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

MongoRegex ha sido obsoleto.
Use MongoDB\BSON \ Regex

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

Si estás usando PHP, puedes usar MongoDB_DataObject wrapper como abajo:

$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 like 'last'with status = = 'Pending' between two dates:

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' y OrderID COMO 'PHA876174':

db.orders.find({
     status:"Pending",
     orderId:/PHA876174/
     }).pretty();

db.customer.find({"customerid": {"$regex": "CU_00000*", "$options": "i"}}).pretty()

Cuando estamos buscando patrones de cadena, siempre es mejor usar el patrón anterior como cuando no estamos seguros sobre case. 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
    }
]);