web-dev-qa-db-fra.com

Comment interroger MongoDB avec "like"?

Je veux interroger quelque chose avec la requête like de SQL:

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

Comment faire la même chose dans MongoDB? Je ne trouve pas d'opérateur pour like dans documentation .

sqlmongodbmongodb-querysql-like
1283
Freewind

Cela devrait être:

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

ou similaire:

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

Vous recherchez quelque chose qui contient "m" quelque part (l'opérateur '%' de SQL équivaut à '.*' de Regexp), et non quelque chose qui a un "m" ancré au début de la chaîne.

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

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

out: paulo, patric

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

out: paulo, patric

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

out: pedro

317
Johnathan Douglas

Dans

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

tu peux faire:

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

En PHP, vous pouvez utiliser le code suivant:

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

Vous utiliseriez regex pour cela en mongo.

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

49
Joshua Partogi

Il y a déjà beaucoup de réponses. Je donne différents types d'exigences et de solutions pour la recherche de chaînes avec regex.

Vous pouvez faire avec regex qui contiennent Word i.e like. Vous pouvez aussi utiliser $options => i pour une recherche insensible à la casse.

Contient string

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

Ne contient pas string seulement avec regex

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

Insensible à la casse exacte string

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

Commencez par string

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

Terminez avec string

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

Conservez this en tant que signet et référence pour toute autre modification dont vous pourriez avoir besoin.

40
Somnath Muluk

Si vous utilisez node.js , it indique que vous pouvez écrire ceci:

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

Aussi , vous pouvez écrire ceci:

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

Vous avez 2 choix:

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

ou

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

Sur le second, vous avez plus d'options, comme "i" dans les options pour rechercher en utilisant la casse. Et à propos de la "chaîne", vous pouvez utiliser comme ".chaîne." (% chaîne%), ou "chaîne. *" (Chaîne%) et ". * Chaîne) (% chaîne) pour Vous pouvez utiliser l’expression régulière à votre guise.

Prendre plaisir!

28
user3645907

Déjà, vous avez les réponses, mais pour faire correspondre regex avec insensibilité à la casse

Vous pouvez utiliser la requête suivante

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

La i dans le /m/i indique l'insensibilité à la casse et .pretty() fournit un résultat plus joli.

18
The6thSense

Pour Mongoose dans Node.js

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

Vous pouvez utiliser la nouvelle fonctionnalité 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"
    }
});
11
cmarrero01

Pour PHP mongo Like.
J'ai eu plusieurs problèmes avec php mongo like. J'ai trouvé que concaténer les paramètres regex aide dans certaines situations le champ de recherche de PHP commence par . Je pensais que je posterais ici pour contribuer au fil plus populaire

par exemple

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)
11
Dap

Dans nodejs projetez et utilisez mangouste utilisez comme une requête 

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);
            });
9
Shaishab Roy

Avec MongoDB Compass, vous devez utiliser la syntaxe de mode strict, comme suit:

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

(Dans MongoDB Compass, il est important d’utiliser " au lieu de '.)

8
damd

En SQL, la requête "like" ressemble à ceci:

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

Dans la console MongoDB, cela ressemble à ceci:

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

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

De plus, la méthode pretty() générera dans tous les endroits où la structure JSON formatée est plus lisible.

8
MAA

Les regex coûtent cher sont un processus.

Une autre méthode consiste à créer un index de texte, puis à le rechercher à l'aide de $search.

Créez un index textuel des champs que vous souhaitez rendre consultables:

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

Rechercher une chaîne dans l'index de texte:

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

Utilisez les expressions régulières correspondantes comme ci-dessous. Le 'i' montre une insensibilité à la casse.

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

Dans Go et le pilote mgo:

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

où result est l'instance de struct du type recherché

7
user2312578

Vous pouvez utiliser l'instruction where pour construire n'importe quel script JS:

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

Référence: http://docs.mongodb.org/manual/reference/operator/where/

7
brenoriba

Il semble qu'il y ait des raisons d'utiliser à la fois le motif javascript /regex_pattern/ ainsi que le motif mongo {'$regex': 'regex_pattern'}. Voir: Restrictions de la syntaxe MongoBD RegEx

Ce n'est pas un tutoriel complet sur RegEx, mais j'ai été inspiré pour exécuter ces tests après avoir vu un post très ambigu sur les votes hautement ambigu) .

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

Like Query serait comme indiqué ci-dessous

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

pour 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]
5
prayagupd

Si vous utilisez Spring-Data Mongodb, vous pouvez procéder de la manière suivante:

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

En tant que support regex de Mongo Shell, c'est tout à fait possible.

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

Si nous voulons que la requête ne respecte pas la casse, nous pouvons utiliser l'option "i", comme illustré ci-dessous:

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

Si vous voulez une recherche 'J'aime' dans Mongo, alors vous devriez utiliser $ regex en utilisant cette requête

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

pour plus d'informations, vous pouvez également lire la documentation. https://docs.mongodb.com/manual/reference/operator/query/regex/

4
jarry jafery

L'utilisation de littéraux de modèle avec des variables fonctionne également:

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

3
besthost

J'ai trouvé un outil gratuit pour traduire les requêtes MYSQL en MongoDB. http://www.querymongo.com/ J'ai vérifié avec plusieurs requêtes. comme je vois presque tous sont corrects. D'après cela, la réponse est

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

Utilisez la recherche de sous-chaînes d'agrégation (avec index !!!):

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

MongoRegex est obsolète.
Utiliser MongoDB\BSON\Regex

$regex = new MongoDB\BSON\Regex ( '^m');
$cursor = $collection->find(array('users' => $regex));
//iterate through the cursor
2
Albert s
db.customer.find({"customerid": {"$regex": "CU_00000*", "$options": "i"}}).pretty()

Lorsque nous recherchons des modèles de chaîne, il est toujours préférable d'utiliser le modèle ci-dessus, car nous ne sommes pas sûrs de la casse. J'espère que ça t'as aidé!!!

1
priya raj

FullName comme 'last' avec le statut == 'En attente ’entre deux dates:

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 == 'En attente' et orderId LIKE 'PHA876174':

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

Si vous utilisez PHP, vous pouvez utiliser MongoDB_DataObject comme ci-dessous:

$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);
}
1
CEDA
>> db.car.distinct('name')
[ "honda", "tat", "tata", "tata3" ]

>> db.car.find({"name":/. *ta.* /})
0
arnav

Vous pouvez également utiliser le filtre générique comme suit:

{"query": { "wildcard": {"lookup_field":"search_string*"}}}

assurez-vous d'utiliser *.

0
saim2025

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, dipak, parmar

0
Deepak parmar