Como interrogar o MongoDB com "gostar"?
quero perguntar algo como a consulta do SQL like
:
select *
from users
where name like '%m%'
Como fazer o mesmo em MongoDB?Não consigo encontrar um operador para
like
nas documentações.
30 answers
db.users.find({"name": /.*m.*/})
Ou semelhantes:
db.users.find({"name": /m/})
Você está procurando algo que contém " m " em algum lugar (operador SQL 's' %
'é equivalente Ao' .*
'da Regexp), não algo que tem" m " ancorado ao início da cadeia.
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
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/})
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.
Divirtam-se!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"
}
});
Tive vários problemas com o php mongo. descobri que a concatenação dos parâmetros regex ajuda em algumas situações o campo PHP mongo find começa com. Eu pensei que eu iria postar aqui para contribuir para o tópico mais 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)
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%'
Na consola MongoDB, parece isto:
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"}
})
Usar MongoDB\BSON\Regex
$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
}
]);