Comment interroger MongoDB avec "j'aime"?

Je veux interroger quelque chose avec la likerequête SQL :

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

Comment puis-je obtenir la même chose dans MongoDB? Je ne trouve pas d'opérateur likedans la documentation .

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 est équivalent à « .*» de Regexp ), pas quelque chose qui a «m» ancré au début de la chaîne.

note: mongodb utilise des expressions régulières plus puissantes que "LIKE" en sql. Avec des expressions régulières, vous pouvez créer n'importe quel motif que vous imaginez.

Pour plus d'informations sur les expressions régulières, reportez-vous à ce lien 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%'

sortie: paulo, patric

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

sortie: paulo, patric

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

sortie: pedro

Dans

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

tu peux faire:

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

En PHP, vous pouvez utiliser le code suivant:

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

Vous utiliseriez regex pour cela en mongo.

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

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

Vous pouvez le faire avec des expressions rationnelles qui contiennent des mots ie comme. Vous pouvez également utiliser $options => ipour la recherche insensible à la casse

Contient string

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

Ne contient pas stringuniquement avec regex

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

Insensible à la casse exacte string

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

Commencer avec string

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

Terminer par string

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

Conservez -le comme un signet et une référence pour toute autre modification dont vous pourriez avoir besoin.

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 trouver 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) par exemple. Vous pouvez utiliser l'expression régulière comme tu veux.

Prendre plaisir!

Si vous utilisez node.js , il est écrit que vous pouvez écrire ceci:

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

En outre , vous pouvez écrire ceci:

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

Vous avez déjà obtenu les réponses, mais pour faire correspondre l'expression rationnelle avec l'insensibilité à la casse

Vous pouvez utiliser la requête suivante

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

Le idans le /m/iindique une insensibilité à la casse et .pretty()fournit une sortie plus jolie

Pour Mongoose dans Node.js

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

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

Dans le projet nodejs et utilisez mangouste, utilisez la requête Like

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

Pour PHP mongo Like.
J'ai eu plusieurs problèmes avec php mongo comme. J'ai trouvé que la concaténation des paramètres regex aide dans certaines situations, le champ de recherche PHP mongo commence par . Je pensais que je posterais ici pour contribuer au fil le 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)

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

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

Avec MongoDB Compass, vous devez utiliser la syntaxe de mode strict, en tant que telle:

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

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

Vous pouvez utiliser l'instruction where pour créer 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/

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

En outre, la pretty()méthode produira à tous les endroits où la structure JSON formatée sera plus lisible.

Les regex coûtent cher.

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

Créez un index de texte des champs que vous souhaitez rendre consultable:

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

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

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

Dans Go et le pilote mgo:

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

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

Utilisez des expressions régulières correspondant 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);

Comme la requête 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]

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

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

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

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

Comme le shell Mongo supporte les 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});

Si vous voulez une recherche «J'aime» dans mongo, vous devriez utiliser $ regex en utilisant cette requête.

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

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

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

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

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. Selon cela, la réponse est

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

MongoRegex est obsolète.
Utilisez 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()

Lorsque nous recherchons des modèles de chaîne, il est toujours préférable d'utiliser le modèle ci-dessus comme lorsque nous ne sommes pas sûrs de la casse. J'espère que cela pourra aider!!!