Comment interroger MongoDB avec"like"?
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.
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
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'}})
en PHP, vous pouvez utiliser le code suivant:
$collection->find(array('name'=> array('$regex' => 'm'));
vous utiliseriez regex pour ça dans mongo.
E. g: db.users.find({"name": /^m/})
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') } );
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.
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!
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
pour Mangouste en noeud.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"
}
});
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)
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);
});
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 /
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.
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);
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]
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 '
)
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 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});
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 /
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" }
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%"
});
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"}
})
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
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);
}
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();
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!!!
Use agrégation recherche par soustraitance (avec index!!!):
db.collection.aggregate([{
$project : {
fieldExists : {
$indexOfBytes : ['$field', 'string']
}
}
}, {
$match : {
fieldExists : {
$gt : -1
}
}
}, {
$limit : 5
}
]);