¿Cómo consultar MongoDB con "me gusta"?

Quiero consultar algo con la likeconsulta de SQL :

SELECT * FROM users  WHERE name LIKE '%m%'

¿Cómo hago para lograr lo mismo en MongoDB? No puedo encontrar un operador likeen la documentación .

Eso tendría que 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 "m" anclado al comienzo de la cadena.

nota: mongodb usa expresiones regulares que son más poderosas que "LIKE" en sql. Con expresiones regulares puedes crear cualquier patrón que imagines.

Para obtener más información sobre expresiones regulares, consulte este enlace https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions

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, puede usar el siguiente código:

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

Usarías regex para eso en mongo.

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

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

Puede hacerlo con expresiones regulares que contienen palabras, es decir, me gusta. También puede usar $options => ipara la búsqueda sin distinción entre mayúsculas y minúsculas

Contiene string

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

No contiene stringsolo con expresiones regulares

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

Caso exacto insensible string

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

Empezar con string

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

Terminar con string

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

Conserve esto como un marcador y como referencia para cualquier otra modificación que pueda necesitar.

Tienes 2 opciones:

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

o

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

En el segundo, tiene más opciones, como "i" en las opciones para encontrar usando mayúsculas y minúsculas. Y sobre la "cadena", puede usar como ". Cadena " (% cadena%) o "cadena. *" (Cadena%) y ". * Cadena) (% cadena) por ejemplo. Puede usar expresiones regulares como tu quieras

¡Disfrutar!

Si el uso de Node.js , se dice que se puede escribir lo siguiente:

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 tienes las respuestas, pero para que coincida la expresión regular con insensibilidad a mayúsculas y minúsculas

Puedes usar la siguiente consulta

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

En iel /m/icaso indica insensibilidad al caso y .pretty()proporciona una salida más bonita

Para Mangosta 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"
    }
});

En el proyecto nodejs y use mangosta, 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);
            });

Para PHP Mongo Like.
Tuve varios problemas con php mongo como. descubrí que la concatenación de los parámetros de expresiones regulares ayuda en algunas situaciones con las que comienza PHP mongo find field . 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)

Usar plantillas literales con variables también funciona:

{"firstname": {$regex : `^${req.body.firstname}.*` , $options: 'si' }}

Con MongoDB Compass, debe usar la sintaxis de modo estricto, como tal:

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

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

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 'me gusta ' 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

Además, el pretty()método incluirá en todos los lugares donde se produzca una estructura JSON formateada que sea más legible.

Regex son caros 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'});

Busque una cadena en el índice de texto:

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

En Go y el controlador mgo:

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

donde resultado es la instancia de estructura del tipo buscado

Use expresiones regulares que coincidan 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);

Like Mery 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]

Parece que hay razones para usar tanto el /regex_pattern/patrón javascript como el {'$regex': 'regex_pattern'}patrón mongo . Ver: Restricciones de sintaxis de 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 muy 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" }

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 admite 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, entonces debe ir con $ regex usando esta consulta será

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

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

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

Cadena deepakparmar, dipak, parmar

db.getCollection('yourdb').find({"name":/^dee/})

ans deepakparmar

db.getCollection('yourdb').find({"name":/d/})

ans deepakparmar, dipak

db.getCollection('yourdb').find({"name":/mar$/})

ans deepakparmar, parmar

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

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

MongoRegex ha quedado en desuso.
Utilice MongoDB \ BSON \ Regex

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

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

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