Como consultar o MongoDB com "like"?

Eu quero consultar algo com a likeconsulta do SQL :

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

Como faço para conseguir o mesmo no MongoDB? Não consigo encontrar um operador likena documentação .

Isso teria que ser:

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

ou similar:

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

Você está procurando algo que contenha "m" em algum lugar (o %operador ' ' do SQL é equivalente ao ' .*' da Regexp ) ', não algo que tenha "m" ancorado no início da string.

nota: o mongodb usa expressões regulares que são mais poderosas que "LIKE" no sql. Com expressões regulares, você pode criar qualquer padrão que imaginar.

Para obter mais informações sobre expressões regulares, consulte este link 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%'

fora: paulo, patric

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

fora: paulo, patric

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

fora: pedro

No

• PyMongo usando Python
• Mongoose usando Node.js
• Jongo , usando Java
• mgo , usando Go

você pode fazer:

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

No PHP, você pode usar o seguinte código:

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

Você usaria regex para isso no mongo.

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

Já existem muitas respostas. Estou fornecendo diferentes tipos de requisitos e soluções para pesquisa de strings com regex.

Você pode fazer com o regex que contém a palavra, por exemplo, like. Além disso, você pode usar $options => ipara pesquisa que não diferencia maiúsculas de minúsculas

Contém string

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

Não contém stringapenas regex

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

Insensível a maiúsculas e minúsculas string

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

Começar com string

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

Terminar com string

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

Mantenha isso como marcador e referência para quaisquer outras alterações que você possa precisar.

Você tem 2 opções:

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

ou

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

No segundo, você tem mais opções, como "i" nas opções para encontrar o uso de maiúsculas e minúsculas. E sobre a "string", você pode usar como ". String. " (% String%) ou "string. *" (String%) e ". * String) (% string), por exemplo. Você pode usar expressões regulares como você quiser.

Aproveitar!

Se você estiver usando o node.js , ele diz que você pode escrever isso:

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

Além disso , você pode escrever isso:

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

Você já conseguiu as respostas, mas para combinar regex com insensibilidade a maiúsculas e minúsculas

Você poderia usar a seguinte consulta

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

O ina /m/iindica caso insensibilidade e .pretty()fornece uma saída mais bonita

Para Mongoose no Node.js

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

Você pode usar o novo recurso do 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"
    }
});

No nodejs project e 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);
            });

Para o PHP mongo Like.
Eu tive vários problemas com o php mongo like. Eu descobri que concatenar os parâmetros do regex ajuda em algumas situações o PHP mongo find field começa com . Eu pensei em postar aqui para contribuir com o tópico mais popular

por exemplo

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 literais de modelo com variáveis ​​também funciona:

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

Com o MongoDB Compass, você precisa usar a sintaxe do modo estrito, como:

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

(No MongoDB Compass, é importante que você use em "vez de ')

Você pode usar a instrução where para criar qualquer script JS:

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

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

No SQL, a consulta ' like ' é assim:

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

No console do MongoDB, fica assim:

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

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

Além disso pretty()método irá em todos os lugares onde produzir estrutura JSON formatada que é mais legível.

Regex são caros são processo.

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

Crie um índice de texto dos campos que você deseja tornar pesquisável:

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

Procure uma sequência no índice de texto:

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

No Go e o driver mgo:

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

em que result é a instância struct do tipo procurado

Use expressões regulares correspondentes como abaixo. O 'i' mostra insensibilidade 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);

Como Query seria como mostrado abaixo

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 existem razões para usar o /regex_pattern/padrão javascript e o mongo {'$regex': 'regex_pattern'}. Consulte: Restrições de sintaxe MongoBD RegEx

Este não é um tutorial completo do RegEx, mas fui inspirado a executar esses testes depois de ver uma postagem ambígua altamente votada 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" }

Se você estiver usando o Spring-Data Mongodb, poderá fazer isso desta maneira:

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

Como o shell Mongo suporta regex, isso é completamente possível.

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

Se quisermos que a consulta não diferencie maiúsculas de minúsculas, podemos usar a opção "i", como mostrado abaixo:

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

Se você quiser uma pesquisa 'Like' no mongo, deverá usar $ regex usando esta consulta.

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

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

Use a pesquisa de substring de agregação (com índice !!!):

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

String 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

Encontrei uma ferramenta gratuita para traduzir consultas MYSQL para o MongoDB. http://www.querymongo.com/ Verifiquei com várias consultas. como eu vejo quase todos eles estão corretos. De acordo com isso, a resposta é

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

O MongoRegex foi preterido.
Use 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()

Quando estamos pesquisando padrões de cadeia, sempre é melhor usar o padrão acima como quando não temos certeza sobre o caso. Espero que ajude!!!