MongoDB'yi “like” ile nasıl sorgulayabilirim?

SQL sorgusu ile bir şey sorgulamak istiyorum like:

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

Aynı şeyi MongoDB'de nasıl başarabilirim? Ben için bir operatör bulamıyorum likeiçinde belgeler .

Bunun olması gerekir:

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

veya benzeri:

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

Bir yerde "m" içeren bir şey arıyorsunuz (SQL ' %' operatörü Regexp ' ' ile eşdeğerdir..* ' ), dizenin başına "m" sabitlenmiş bir şey değil.

Not: mongodb sql "GİBİ" daha güçlü olan düzenli ifadeler kullanır. Düzenli ifadeler ile hayal ettiğiniz herhangi bir desen oluşturabilirsiniz.

Normal ifadeler hakkında daha fazla bilgi için bu bağlantıya bakın 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%'

Çıkan: paulo, Patric

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

Çıkan: paulo, Patric

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

Çıkan: pedro

İçinde

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

yapabilirsin:

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

PHP'de aşağıdaki kodu kullanabilirsiniz:

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

Mongo'da bunun için normal ifade kullanırsınız.

Örneğin: db.users.find({"name": /^m/})

Zaten birçok cevap var. Regex ile dize arama için farklı türde gereksinimleri ve çözümleri veriyorum.

Yani kelime içeren regex ile yapabilirsiniz. Ayrıca büyük / $options => iküçük harfe duyarlı olmayan aramalar için de kullanabilirsiniz

İçeren string

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

Değil İçeren mu stringsadece regex ile

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

Tam büyük / küçük harfe duyarlı değil string

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

İle başla string

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

İle bitmek string

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

Bunu bir yer imi ve ihtiyacınız olabilecek diğer değişiklikler için bir referans olarak saklayın .

2 seçeneğiniz var:

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

veya

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

İkincisi, büyük / küçük harfe duyarlı olmayanları bulmak için seçeneklerde "i" gibi daha fazla seçeneğiniz vardır. Ve "string" hakkında, örneğin ". String. " (% String%) veya "string. *" (String%) ve ". * String) (% string) gibi kullanabilirsiniz. Normal ifade kullanabilirsiniz istediğin gibi.

Zevk almak!

Node.js kullanıyorsanız , bunu yazabileceğinizi söyler:

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

Ayrıca , şunu yazabilirsiniz:

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

Zaten cevapları aldım ama normal ifadeyi büyük / küçük harf duyarsızlığıyla eşleştirmek için

Aşağıdaki sorguyu kullanabilirsiniz

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

iİçinde /m/ivaka duyarsız belirtir ve .pretty()daha güzel çıktı sağlar

Node.js'deki Mongoose için

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

2.6 mongodb'un yeni özelliğini kullanabilirsiniz:

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

Gelen nodejs proje ve kullanım firavunfaresi kullanımı sorgusu gibi

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

PHP mongo için Like.
Ben php mongo gibi birkaç sorunları vardı. regex params birleştirilmesi bazı durumlarda PHP mongo bulmak alan yardımcı olur bulundu . Daha popüler bir konuya katkıda bulunmak için buraya göndereceğimi düşündüm

Örneğin

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)

Şablon değişmezlerini değişkenlerle kullanmak da işe yarar:

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

MongoDB Compass ile katı mod sözdizimini kullanmanız gerekir, örneğin:

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

(MongoDB Compass'ta "bunun yerine kullanmanız önemlidir ')

Herhangi bir JS betiği oluşturmak için where deyimini kullanabilirsiniz:

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

Referans: http://docs.mongodb.org/manual/reference/operator/where/

SQL'de, ' like ' sorgusu şöyle görünür:

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

MongoDB konsolunda şöyle görünür:

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

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

Ekleme pretty()yöntemi daha okunabilir biçimlendirilmiş JSON yapısı üretmek tüm yerlerde olacaktır.

Regex pahalı işlemidir.

Başka bir yol, bir metin dizini oluşturmak ve daha sonra kullanarak arama yapmaktır $search .

Aranabilir olmasını istediğiniz alanların metin dizinini oluşturun:

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

Metin dizininde bir dize arayın:

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

Go ve mgo sürücüsünde:

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

sonuç, aranan türün yapısal örneğidir

Aşağıdaki gibi eşleşen normal ifadeler kullanın. 'İ' büyük / küçük harf duyarsızlığını gösterir.

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

Sorgu aşağıdaki gibi olurdu

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

scala ReactiveMongo api için,

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]

Görünüşe göre hem javascript /regex_pattern/deseninin hem de mongo {'$regex': 'regex_pattern'}deseninin kullanılmasının nedenleri var . Bkz: MongoBD RegEx Sözdizimi Kısıtlamaları

Bu tam bir RegEx eğitimi değil, ancak yukarıda yüksek oy alan belirsiz bir yazı gördükten sonra bu testleri çalıştırmak için ilham aldım .

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

Spring-Data Mongodb kullanıyorsanız, bunu şu şekilde yapabilirsiniz:

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

Mongo kabuğu regex'i desteklediğinden, bu tamamen mümkündür.

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

Sorgunun büyük / küçük harfe duyarsız olmasını istiyorsak, aşağıda gösterildiği gibi "i" seçeneğini kullanabiliriz:

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

Moğolda 'Beğen' aramasını istiyorsanız, bu sorguyu kullanarak $ regex ile gitmelisiniz

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

daha fazlası için belgeleri de okuyabilirsiniz. https://docs.mongodb.com/manual/reference/operator/query/regex/

Toplama alt dize aramasını kullan (indeks ile !!!):

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

MYSQL sorgularını MongoDB'ye çevirmek için ücretsiz bir araç buldum. http://www.querymongo.com/ Birkaç sorgu ile kontrol ettim. gördüğüm gibi hemen hemen hepsi doğru. Buna göre, cevap

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

MongoRegex kullanımdan kaldırıldı.
MongoDB \ BSON \ Regex Kullan

$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()

Dize kalıplarını ararken, durumdan emin olmadığımız gibi yukarıdaki deseni kullanmak her zaman daha iyidir. Umarım yardımcı olur!!!