Comment interroger MongoDB avec"like"?

je veux interroger quelque chose comme requête de SQL like :

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

Comment faire la même chose à MongoDB?

Je ne trouve pas d'opérateur pour like dans les documentations .

1095
demandé sur shA.t 2010-07-22 07:19:21

30 réponses

qui devrait être:

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

ou, similaire:

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

vous cherchez quelque chose qui contient" m "quelque part (l'opérateur de SQL ' % 'est équivalent à Regexp ' .* '), pas quelque chose qui a" m " ancré au début de la chaîne.

1479
répondu Kyle H 2017-01-14 04:07:37
db.users.insert({name: 'paulo'})
db.users.insert({name: 'patric'})
db.users.insert({name: 'pedro'})

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

: paulo, patric

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

: paulo, patric

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

: pedro

249
répondu Johnathan Douglas 2015-01-28 18:53:40

Dans

  • PyMongo utilisant Python
  • Mangoose utilisant noeud.js
  • Jongo , en utilisant Java
  • mgo , en utilisant Go

vous pouvez le faire:

db.users.find({'name': {'$regex': 'sometext'}})
199
répondu Afshin Mehrabani 2017-04-27 13:17:41

en PHP, vous pouvez utiliser le code suivant:

$collection->find(array('name'=> array('$regex' => 'm'));
76
répondu leon 2015-06-10 10:04:26

vous utiliseriez regex pour ça dans mongo.

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

43
répondu Joshua Partogi 2010-07-22 03:48:56

si vous utilisez noeud.js , il , dit 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') } );
26
répondu Eddy 2016-09-21 07:44:03

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

vous pouvez faire avec regex qui contiennent le mot I. e comme. Vous pouvez également utiliser $options => i pour la 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'}})

Exact insensible à la casse string

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

commence par string

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

fin avec string

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

Garder ce comme un signet, et une référence pour toutes les autres modifications que vous pourriez avoir besoin.

23
répondu Somnath Muluk 2016-08-11 15:39:09

vous avez 2 choix:

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

ou

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

sur la deuxième vous avez plus d'options, comme" i " dans les options pour trouver en utilisant insensible cas. Et à propos de la" corde", vous pouvez utiliser comme". de la chaîne. " (%chaîne de caractères%), ou "chaîne de caractères.*" (chaîne de caractères%) et ".*string) (%chaîne de caractères) par exemple. Vous pouvez utiliser l'expression régulière comme vous voulez.

Profitez-en!

15
répondu user3645907 2017-09-25 21:58:19

déjà u obtenu les réponses, mais pour faire correspondre regex avec l'insensibilité cas

vous pouvez utiliser la requête suivante

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

le i dans le /m/i indique l'insensibilité de cas et .pretty() fournit une sortie plus jolie

14
répondu The6thSense 2015-11-23 11:21:39

pour Mangouste en noeud.js

db.users.find({'name': {'$regex': '.*sometext.*'}})
11
répondu Aqib Mumtaz 2015-11-10 11:39:29

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"
    }
});
10
répondu cmarrero01 2014-08-04 19:19:03

Pour PHP mongo Comme.

J'ai eu plusieurs problèmes avec php mongo comme. j'ai trouvé que la concaténation des params regex aide dans certaines situations PHP mongo find field commence par . J'ai pensé que je posterais sur ici pour contribuer au fil plus populaire

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)
9
répondu Dap 2017-05-23 12:18:14

Dans nodejs "151930920 de projet et de l'utilisation de la mangouste utiliser Comme 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);
            });
8
répondu Shaishab Roy 2016-05-10 18:57:51

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 /

6
répondu Crasher 2013-09-05 14:53:27

dans SQL, le ’ comme 'requête est ressemble à ceci:

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

dans la console MongoDB, il ressemble à ceci:

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

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

en plus pretty() méthode sera dans tous les endroits où produire la structure JSON formatée qui est plus lisible.

6
répondu MAA 2014-03-19 11:15:12

utilisez les expressions régulières correspondant comme ci-dessous. Le " i " montre de l'insensibilité.

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);
6
répondu Shalabh Raizada 2016-05-16 11:20:25

En Aller, et le mgo pilote:

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

où résultat est l'instance structurelle du type recherché

5
répondu 2014-03-17 21:50:16

Comme Requête serait comme indiqué ci-dessous

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

for 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]
4
répondu prayagupd 2015-05-18 09:55:15

avec MongoDB Compass, vous devez utiliser la syntaxe de mode stricte, comme tel:

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

(en MongoDB Compass, il est important que vous utilisiez " au lieu de ' )

4
répondu damd 2017-04-19 08:01:35

si vous utilisez Spring-Data Mongodb vous pouvez le faire de cette façon:

String tagName = "m";
Query query = new Query();
query.limit(10);        
query.addCriteria(Criteria.where("tagName").regex(tagName));
3
répondu Vaibhav 2015-04-28 10:34:23

comme Mongo shell support regex, c'est tout à fait possible.

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

si nous voulons que la requête soit insensible à la casse, nous pouvons utiliser l'option "i", comme indiqué ci-dessous:

db.users.findOne({"name" : /.*sometext.*/i});
3
répondu sravanthi 2016-01-19 08:09:23

si vous voulez rechercher 'Like' dans mongo alors vous devriez aller avec $ regex en utilisant cette requête sera

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

pour davantage, vous pouvez lire la documentation. https://docs.mongodb.com/manual/reference/operator/query/regex /

3
répondu jarry jafery 2016-08-23 15:03:51

il semble qu'il y ait des raisons d'utiliser à la fois le motif javascript /regex_pattern/ et le motif mongo {'$regex': 'regex_pattern'} . Voir: MongoBD Restrictions De Syntaxe RegEx

ce n'est pas un tutoriel complet de RegEx, mais j'ai été inspiré pour exécuter ces tests après avoir vu un poste très ambigu voté au-dessus de .

> ['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" }
3
répondu Bruno Bronosky 2017-05-23 12:02:53

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 le vois presque tous sont corrects. D'après cela, la réponse est

db.users.find({
    "name": "%m%"
});
2
répondu Lakmal Vithanage 2016-12-06 05:07:03

Regex sont coûteux sont Processus.

une autre façon est de créer un index de texte et ensuite de le rechercher en utilisant $search .

créez un Index texte des champs que vous souhaitez rendre consultable:

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

recherche d'une chaîne de caractères dans l'index des textes:

db.collection.find({
  '$text'=>{'$search': "The string"}
})
2
répondu user3284463 2018-05-16 05:59:08

MongoRegex a été déprécié.

Utiliser MongoDB\BFILS\Regex

$regex = new MongoDB\BSON\Regex ( '^m');
$cursor = $collection->find(array('users' => $regex));
//iterate through the cursor
1
répondu Albert s 2017-01-27 20:06:51

si vous utilisez PHP, vous pouvez utiliser MongoDB_DataObject wrapper like below:

$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
répondu CEDA 2017-02-16 08:34:08

FullName comme "dernier" avec status==’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 n ° de commande COMME " PHA876174’:

db.orders.find({
     status:"Pending",
     orderId:/PHA876174/
     }).pretty();
1
répondu Shubham Verma 2017-05-06 08:38:57
db.customer.find({"customerid": {"$regex": "CU_00000*", "$options": "i"}}).pretty()

quand nous cherchons des motifs de chaîne, il est toujours préférable d'utiliser le motif ci-dessus comme quand nous ne sommes pas sûrs de cas. Espérons que ça aide!!!

1
répondu priya raj 2017-06-02 06:06:13

Use agrégation recherche par soustraitance (avec index!!!):

db.collection.aggregate([{
        $project : {
            fieldExists : {
                $indexOfBytes : ['$field', 'string']
            }
        }
    }, {
        $match : {
            fieldExists : {
                $gt : -1
            }
        }
    }, {
        $limit : 5
    }
]);
1
répondu kz_sergey 2018-01-03 19:16:55