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

Quiero consultar algo con SQL like consulta:

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

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

preguntado el 22 de julio de 10 a las 00:07

ver los documentos de mongodb: Consultas avanzadas - Expresiones regulares mongodb.org/display/DOCS/… -

Tu pregunta tiene al menos 5 votos por el operador similar etiqueta. ¿Podría pedirle amablemente que sugiera similar a sql como herramienta de edición del sinónimo? -

Este enlace puede ayudarte goo.gl/gdTYK8 -

db.users.find ({'nombre': {'$ regex': 'algún texto', '$ opciones': 'i'}}) -

30 Respuestas

Eso tendría que ser:

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

o similar:

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

Estás buscando algo que contenga "m" en algún lugar (SQL's '%'operador es equivalente a Regexp's'.*'), no algo que tenga "m" anclada al principio 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

respondido 14 nov., 19:12

¿Es caro buscar por expresiones regulares? - El viento libre

De hecho, depende. Si la consulta no usa un índice y debe realizar un escaneo de tabla, entonces ciertamente puede ser costoso. Si está haciendo una consulta de expresiones regulares 'comienza con', entonces puede usar un índice. Es mejor ejecutar una explicación () para ver qué está sucediendo. - Banquero Kyle

Cuando no está anclado al principio de la cuerda, es algo caro. Pero, de nuevo, también lo es un LIKE consulta en SQL. - Emily

así que mientras esté anclado al principio de la cuerda, ¿está bien? genial entonces. ¿Eso significa que necesitamos agregar ^ - user4951

Yo agregaría regex i javascript db.users.find({ "name": { $regex: /m/i } }) - Doron Segal

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

Respondido el 28 de enero de 15 a las 18:01

buen ejemplo! Estoy encontrando el final del cheque con espacio y encontré esto :) / $ / - Phuong

¿Cómo encuentras todas las entradas para el nombre? o el comodín para * en SQL? Algo que hace select name from users; que solo enumera a todos los usuarios? - anon58192932

@ anon58192932 Para mostrar todas las entradas de solo el campo "nombre" en una tabla llamada "usuarios", puede usar el método project () configurando los valores de los campos que desea 1. Los campos que no se mencionan en project () no se obtenido excepto _id. El campo _id se imprime de forma predeterminada, lo que puede suprimir poniendo el valor 0 para _id dentro del método project (). Algo como - db.collection.find (). Project ({nombre: 1, _id: 0}) .toArray (function (err, docs) {console.log (docs); callback (docs);}); Refiera esto - docs.mongodb.com/manual/tutorial/… - gauravparmar

In

  • PyMongo usar Python
  • Mangosta usar Node.js
  • jong, utilizando Java
  • mgo, utilizando Go

tu puedes hacer:

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

Respondido 27 Abr '17, 14:04

funciona bien para la búsqueda que distingue entre mayúsculas y minúsculas, ¿podría decirme cómo puedo hacer que funcione para realizar una búsqueda que no distinga entre mayúsculas y minúsculas? - Tahir Yasin

¿Cuál sería la expresión regular para %sometext% - Tahir Yasin

@TahirYasin si todavía se lo está preguntando, la búsqueda sin distinción entre mayúsculas y minúsculas se haría así: db.users.find({'name': {'$regex': 'sometext', '$options': 'i'}}) - luchador de sumo

Resolví en golang usando mgo simplemente un código como este, selector: = bson.M {"technician": bson.M {"$ regex": tech}} - Sandún Priyanka

@SandunPriyanka la biblioteca mgo tiene un tipo de expresión regular incorporado, debe usar bson.M{"technician", bson.RegEx{Pattern: tech}} en su lugar (pero asegúrese de que tech ha sido desinfectado o, de lo contrario, tiene una vulnerabilidad de inyección de expresiones regulares!) - kbolino

En PHP, puede usar el siguiente código:

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

Respondido el 10 de junio de 15 a las 11:06

python + mongoengine: people = People.objects.raw_query ({'nombre': {'$ regex': 'm'}}) - panchocore

Si su valor de RegEx se origina a partir de la entrada del usuario (por ejemplo, un formulario de filtro) y no desea que el valor en sí se tome como una RegExp, debe aplicar preg_quote (). - Felipe Rieber

Me acabo de dar cuenta de esto, pero esta es en realidad la respuesta incorrecta, aunque funciona, es subóptimo, en su lugar debe usar el objeto de expresión regular BSON real a través de MongoRegex, $ regex tiene problemas de compatibilidad con ciertos comandos como $ in - sammaye

Esta sintaxis es útil si el valor se almacena en una variable, por lo que la consulta podría escribirse como (en Ruby): $collection.where(field => {"$regex" => value}) - donny kurnia

Pero, ¿por qué no puedes usar matrices literales? - Alper

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 la palabra, es decir, me gusta. También puedes usar $options => i para búsqueda que no distingue entre 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'}})

No distingue entre mayúsculas y minúsculas string

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

Comience con string

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

Terminar con string

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

Guardar este como marcador y referencia para cualquier otra modificación que pueda necesitar.

Respondido 11 ago 16, 16:08

Usaría expresiones regulares para eso en mongo.

p.ej:

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

Respondido 04 Feb 21, 16:02

Creo que esto solo muestra documentos con un valor de nombre que comienza con "m" - Jack Ace

Su muestra es similar a LIKE 'm%' no LIKE '% m%' - mahoor13

Tienes 2 opciones:

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

or

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

En el segundo, tiene más opciones, como "i" en las opciones para encontrar el uso que no distingue entre mayúsculas y minúsculas. Y sobre la "cadena", puedes usar like ".cadena."(% cadena%), o" cadena. * "(cadena%) y". * cadena) (% cadena) por ejemplo. Puede usar expresiones regulares como desee.

¡Que la disfrutes!

Respondido el 25 de Septiembre de 17 a las 22:09

Si usas Node.js, it 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') } );

Respondido el 21 de Septiembre de 16 a las 08:09

Sintaxis similar en Ruby: collection.where(field => Regexp.new(value)) - donny kurnia

Ya tienes las respuestas, pero para hacer coincidir las expresiones regulares con la insensibilidad a mayúsculas y minúsculas

Podrías usar la siguiente consulta

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

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

respondido 23 nov., 15:11

pero ¿qué pasa si quiero establecer un valor dinámicamente aquí? Kansas

@KuldeepKoranga, podría colocar cualquier valor dinámico en lugar de 'm'. Es eso lo que quieres. - El sexto sentido

var search="feacebook" entonces, ¿cómo puedo configurar debajo de @ The6thSens Sí, pero db.users.find ({ "name" : /search/i } ) ? - Kansas

@KuldeepKoranga has asignado el valor. - El sexto sentido

Para Mongoose en Node.js

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

respondido 10 nov., 15:11

Puede utilizar la nueva función 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"
    }
});

Respondido 04 ago 14, 20:08

Tenga en cuenta que la búsqueda de texto de AFAIK Mongodb funciona en palabras completas solo de forma predeterminada, por lo que coincidirá con valores como "Esta es una cadena con texto", pero no "Esta es una cadena con subtexto". Así que no es como el operador "LIKE" de sql. - cohetes

@Rocketmonkeys es cierto ... para algo como "operador LIKE", usaría el operador $ regex mongo. - cmarrero01

In nodejs proyectar y usar uso de mangosta 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);
            });

contestado el 10 de mayo de 16 a las 19:05

¿Cómo puedo usar una consulta similar? He intentado esto pero no funciona: searchQuery.product_name = '/'+req.query.search.value+'/i'; - Muhammad Shahzad

puede intentar como: searchQuery.product_name= {$regex: req.query.search.value, $options: 'i'}; - Shaishab Roy

Me salvas la vida, amigo. ¿Puede explicar un poco qué es $ regex y $ opciones? - Muhammad Shahzad

if(req.query.search.value){ searchQuery.product_name = {$regex: req.query.search.value, $options: 'i'}; searchQuery.sale_amount = {$regex: req.query.search.value, $options: 'i'}; searchQuery.sale_person = {$regex: req.query.search.value, $options: 'i'}; searchQuery.department_name = {$regex: req.query.search.value, $options: 'i'}; searchQuery.sale_date = {$regex: req.query.search.value, $options: 'i'}; } ¿Puedes mirar por qué esto no funciona? - Muhammad Shahzad

bien $regex: 'value' generar una expresión regular para su valor de búsqueda y $options: 'i' significa insensible a mayúsculas y minúsculas. Su código no funcionó porque usó el mismo valor para diferentes propiedades y eso actúa como y condición que no debe cumplir con su colección de base de datos. - Shaishab Roy

Con MongoDB Compass, debe utilizar la sintaxis del modo estricto, como tal:

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

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

Respondido 19 Abr '17, 09:04

Para PHP mongo Like.
Tuve varios problemas con php mongo como. Descubrí que concatenar los parámetros de expresiones regulares ayuda en algunas situaciones El campo de búsqueda de PHP mongo 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)

contestado el 23 de mayo de 17 a las 13:05

Según las respuestas y comentarios anteriores, la búsqueda de $ text (Index) dará una mejor solución con el punto de referencia en comparación con el método $ regex correcto. Para referencia, consulte este enlace stackoverflow.com/questions/10610131/…. ¿Es posible implementar el método $ text index con PHP y mongoDB? sankar muniyappa

El uso de literales de plantilla con variables también funciona:

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

Respondido el 08 de junio de 18 a las 07:06

Esta es la búsqueda desde el comienzo ex - si "firstname" contiene testlast y si busco por "last" no dará resultado. - vikas chauhan

Puede usar la declaració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/

Respondido el 05 de Septiembre de 13 a las 15:09

$where es muy ineficiente. Hacer un escaneo de colección completo :( - Sushant Gupta

ah, no hay problema, estaba diciendo así: D - Sushant Gupta

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

respondido 17 mar '14, 21:03

Por favor, evite los campos sin clave en los literales. bson:RegEx{Pattern:"m", Options:"i"} en lugar de - bithavoc

En SQL, el 'como'consulta se ve así:

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

En la consola de MongoDB, se ve así:

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

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

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

respondido 19 mar '14, 11:03

Las expresiones regulares son costosas son procesos.

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

contestado el 16 de mayo de 18 a las 06:05

Solución perfecta ... Las expresiones regulares son demasiado caras. Trabajar con un conjunto de datos de 20 millones de documentos y la diferencia de rendimiento es muy, muy notable (lo cual es una subestimación) - nivensookharan

De hecho, este , solamente funciona para palabras completas, ver docs.mongodb.com/manual/core/index-text/#index-entries - Tomas Ebert

Utilice expresiones regulares que coincidan como se muestra a continuación. La 'i' muestra la 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);

contestado el 16 de mayo de 16 a las 12:05

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

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

para scala ReactivoMongo abejas,

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]

contestado el 18 de mayo de 15 a las 10:05

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

Este no es un tutorial completo de RegEx, pero me inspiré para ejecutar estas pruebas después de ver un post ambiguo altamente votado 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" }

contestado el 23 de mayo de 17 a las 13:05

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

Respondido 28 Abr '15, 11:04

Cuerda deepakparmar, dipak, parmar

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

años pakparmar

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

años deepakparmar, dipak

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

años deepakparmar, parmar

Respondido 27 Oct 19, 23:10

Si tiene una variable de cadena, debe convertirla en una expresión regular, por lo que MongoDb usará una declaración similar en ella.

const name = req.query.title; //John
db.users.find({ "name": new Regex(name) });

Es el mismo resultado que:

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

Respondido 04 Feb 21, 16:02

Como el shell de Mongo admite expresiones regulares, 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});

Respondido el 19 de enero de 16 a las 08:01

Si desea buscar 'Me gusta' en mongo, entonces debe ir con $ regex usando esta consulta será

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

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

Respondido 23 ago 16, 16:08

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

Respondido el 03 de enero de 18 a las 19:01

¡bonito! ¿Hay alguna forma de hacer coincidir todo el documento? ¿O hacer que el marco de agregación haga una consulta de seguimiento para hacer eso? Por el momento, un partido se ve así: { "_id" : ObjectId("5aba5ad988385120a01b1ac2"), "fieldExists" : 4 } - Gianfranco P.

en $ project stage solo proyecta lo que quieres - Vocabulario

Puede consultar con una expresión regular:

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

Si la cadena proviene del usuario, tal vez desee escapar de la cadena antes de usarla. Esto evitará que los caracteres literales del usuario se interpreten como tokens de expresiones regulares.

Por ejemplo, buscando la cadena "A" también coincidirá "AB" si no escapó. Puedes usar un simple replace para escapar de su cuerda antes de usarla. Lo convertí en una función para reutilizar:

function textLike(str) {
  var escaped = str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
  return new RegExp(escaped, 'i');
}

Así que ahora, la cadena se convierte en un patrón que no distingue entre mayúsculas y minúsculas y que coincide también con el punto literal. Ejemplo:

>  textLike('A.');
<  /A\./i

Ahora estamos listos para generar la expresión regular sobre la marcha:

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

respondido 31 mar '20, 19:03

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

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

Respondido el 06 de diciembre de 16 a las 05:12

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.