Como interrogar o MongoDB com "gostar"?

db.users.insert({name: 'paulo'})
db.users.insert({name: 'patric'})
db.users.insert({name: 'pedro'})

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

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

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

Fora: pedro

Em

• PyMongo Usando Python
• Mangusto Usando nó.js
• Jongo, usando Java
• mgo , Usando Go

Podes fazer:

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

Em PHP, pode usar o seguinte código:

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

Usarias a regex para isso em mongo.

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

Se utilizar nó.js, diz que podes escrever isto:

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

Também , podes escrever isto:

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

Você pode fazer com regex que contém a palavra i. e. Como. Também pode usar $options => i para uma pesquisa insensível à capitalização

Contém string

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

Não contém string apenas com regex

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

Caso EXACTO insensível string

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

Começa com string

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

Terminar com string

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

Manter isto como um marcador, e uma referência para quaisquer outras alterações que possa precisar.

Tens duas escolhas:

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

Ou

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

Na segunda você tem mais opções, como "i" em opções para encontrar usando o caso insensível. E sobre o "string", você pode usar como".fio. "(%string%), ou " string.* "(string%) and".* string) (%string) por exemplo. Você pode usar a expressão regular como quiser.

Já tens as respostas mas para combinar a regex com a insensibilidade dos casos

Pode usar a seguinte consulta

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

O i no /m/i indica a insensibilidade dos casos e .pretty() fornece uma saída mais bonita

Para Mangusto no nó.js

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

Pode usar a nova funcionalidade 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"
    }
});

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

Você pode usar a indicação onde compilar qualquer programa JS:

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

Referência: http://docs.mongodb.org/manual/reference/operator/where/

Em SQL, a consulta' como ' é assim:

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

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

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

In addion pretty() method will in all the places where produce formatted JSON structure which is more readable.

Usar expressões regulares que correspondam às que se seguem. O " i " Mostra falta de sensibilidade ao caso.

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

In Go and the mgo driver:

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

Em que o resultado é a instância estrutural do tipo pretendido

Como a consulta seria como mostrado abaixo

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

Para scalaReactiveMongo 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]

Com a bússola MongoDB, é necessário usar a sintaxe estrita do modo, como tal:

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

(na bússola MongoDB, é importante que uses " em vez de ')

Se estiver a utilizar o sistema de dados de Primavera Mongodb pode fazer isto desta forma:

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

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

Se queremos que a consulta seja insensível à capitalização, podemos usar a opção "i", como mostrado abaixo:

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

Se quiser a pesquisa 'Like' em mongo, então deverá usar a $regex usando esta pesquisa será

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

Para mais pode ler a documentação também. https://docs.mongodb.com/manual/reference/operator/query/regex/

Parece que existem razões para usar tanto o padrão javascript /regex_pattern/ como o padrão mongo {'$regex': 'regex_pattern'}. Ver: Restrições De Sintaxe RegEx MongoBD

Este não é um tutorial RegEx completo, mas eu fui inspirado para executar estes testes depois de ver um post altamente votado Ambíguo acima .

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

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

O Regex é caro.

Outra maneira é criar um índice de texto e, em seguida, pesquisá-lo usando $search.

Crie um índice de texto dos campos que deseja procurar:

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

Procurar por um texto no índice de texto:

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

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

Se está a usar o PHP, pode usar o invólucroMongodb_ DataObject como em baixo:

$model = new MongoDB_DataObject();

$model->query("select * from users where name like '%m%'");

while($model->fetch()) {
    var_dump($model);
}

Ou:

$model = new MongoDB_DataObject('users);

$model->whereAdd("name like '%m%'");

$model->find();

while($model->fetch()) {
    var_dump($model);
}

Nome Completo Como 'last' com status= = 'Pendente' entre duas datas:

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= = 'Pendente' e orderId como 'PHA876174':

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

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

Quando estamos à procura de padrões de cordas, é sempre melhor usar o padrão acima como quando não temos a certeza sobre o caso. Espero que isso ajude!!!

Usar a pesquisa de subconjuntos de agregação (com índice!!!):

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