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

not like mongodb

Question

Quiero consultar algo como la consulta de SQL:

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

¿Cómo hacer lo mismo en MongoDB?
No puedo encontrar un operador para me like en las documentations .

Answer 1

Como Mongo shell soporta expresiones regulares, eso es completamente posible.

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

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

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

Answer 2

Como Quería 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]

Answer 3

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

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

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

Answer 4

En

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

tu puedes hacer:

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

Answer 5

En Go and the mgo driver:

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

donde resultado es la instancia de estructura del tipo buscado

Answer 6

En PHP, puedes usar el siguiente código:

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

Answer 7

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 método pretty() hará en todos los lugares donde se produzca una estructura JSON formateada que sea más legible.

Answer 8

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

Answer 9

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

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

Answer 10

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 principio de la cadena.

Answer 11

Los regex son costosos son el 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"}
})

Answer 12

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

Answer 13

Para PHP mongo Me gusta.
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 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)

Answer 14

Para la mangosta en Node.js

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

Answer 15

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 sintaxis RegEx de MongoBD

Este no es un tutorial completo de RegEx, pero me inspiraron para realizar 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" }

Answer 16

Puede utilizar 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"
    }
});

Answer 17

Puedes 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/

Answer 18

Si desea realizar una búsqueda ''Me gusta'' en mongo, debe ir con $ regex utilizando esta consulta.

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

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

Answer 19

Si está utilizando PHP, puede usar el contenedor de MongoDB_DataObject como 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);
}

Answer 20

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

Answer 21

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

Also , puedes escribir esto:

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

Answer 22

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 " .cinta " (% string%), o "cadena. *" (Cadena%) y ". * Cadena) (% cadena), por ejemplo. Puede usar una expresión regular como tu quieras

¡Disfrutar!

Answer 23

Usarías expresiones regulares para eso en mongo.

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

Answer 24

Use expresiones regulares que coincidan como se muestra a continuación. La ''i'' muestra insensibilidad a los casos.

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

Answer 25

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

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

Answer 26

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

Usted puede hacer con expresiones regulares que contienen la palabra es decir, como. También puedes usar $options => i para búsquedas sin distinción de 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 insensible caso exacto

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

Comenzar con una string

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

Termina con una string

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

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

Answer 27

Ya tienes las respuestas, pero para hacer coincidir las expresiones regulares con la insensibilidad a los casos

Podrías usar la siguiente consulta.

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

La i en el /m/i indica insensibilidad a los casos y .pretty() proporciona un resultado más bonito

Answer 28

Nombre completo como ''último'' 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();

Answer 29

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

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

Answer 30

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