Bagaimana cara menanyakan MongoDB dengan "suka"?

Saya ingin menanyakan sesuatu dengan likepermintaan SQL :

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

Bagaimana cara saya mencapai hal yang sama di MongoDB? Saya tidak dapat menemukan operator likedalam dokumentasi .

Itu pasti:

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

atau, serupa:

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

Anda sedang mencari sesuatu yang mengandung "m" di suatu tempat ( %operator SQL ' setara dengan Regexp' .*'), bukan sesuatu yang memiliki "m" berlabuh ke awal string.

catatan: mongodb menggunakan ekspresi reguler yang lebih kuat daripada "LIKE" dalam sql. Dengan ekspresi reguler, Anda dapat membuat pola apa pun yang Anda bayangkan.

Untuk info lebih lanjut tentang ekspresi reguler, lihat tautan ini 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%'

keluar: paulo, patric

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

keluar: paulo, patric

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

keluar: pedro

Di

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

Anda dapat melakukan:

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

Di PHP, Anda dapat menggunakan kode berikut:

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

Anda akan menggunakan regex untuk itu di mongo.

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

Sudah ada banyak jawaban. Saya memberikan berbagai jenis persyaratan dan solusi untuk pencarian string dengan regex.

Anda dapat melakukannya dengan regex yang berisi kata seperti like. Anda juga dapat menggunakan $options => iuntuk pencarian case-sensitive

Mengandung string

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

Tidak Berisi stringhanya dengan regex

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

Tidak sensitif case persis string

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

Dimulai dari string

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

Berakhir dengan string

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

Simpan ini sebagai bookmark, dan referensi untuk perubahan lain yang mungkin Anda butuhkan.

Anda memiliki 2 pilihan:

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

atau

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

Yang kedua Anda memiliki lebih banyak opsi, seperti "i" dalam opsi untuk menemukan penggunaan case-insensitive. Dan tentang "string", Anda dapat menggunakan seperti ". String. " (% String%), atau "string. *" (String%) dan ". * String) (% string) misalnya. Anda dapat menggunakan ekspresi reguler seperti yang kamu inginkan.

Nikmati!

Jika menggunakan node.js , itu mengatakan bahwa Anda dapat menulis ini:

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

Juga , Anda dapat menulis ini:

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

Sudah Anda mendapatkan jawaban tetapi untuk mencocokkan regex dengan ketidakpekaan huruf

Anda bisa menggunakan kueri berikut

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

The idalam /m/imenunjukkan kasus ketidakpekaan dan .pretty()memberikan output lebih cantik

Untuk luwak di Node.js

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

Anda dapat menggunakan fitur baru 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"
    }
});

Dalam proyek nodejs dan gunakan luong gunakan Seperti permintaan

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

Untuk PHP mongo Like.
Saya punya beberapa masalah dengan php seperti mongo. Saya menemukan bahwa menggabungkan params regex membantu dalam beberapa situasi PHP mongo menemukan bidang dimulai dengan . Saya pikir saya akan memposting di sini untuk berkontribusi pada utas yang lebih populer

misalnya

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)

Menggunakan templat literal dengan variabel juga berfungsi:

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

Dengan Kompas MongoDB, Anda perlu menggunakan sintaks mode ketat, seperti:

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

(Dalam Kompas MongoDB, penting bahwa Anda menggunakan "bukan ')

Anda dapat menggunakan pernyataan di mana untuk membuat skrip JS:

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

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

Dalam SQL, kueri ' seperti ' terlihat seperti ini:

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

Di konsol MongoDB, tampilannya seperti ini:

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

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

Selain itu pretty()metode akan di semua tempat di mana menghasilkan struktur JSON diformat yang lebih mudah dibaca.

Regex adalah proses yang mahal.

Cara lain adalah dengan membuat indeks teks dan kemudian mencarinya menggunakan $search.

Buat Indeks teks bidang yang ingin Anda cari:

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

Cari string dalam indeks teks:

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

In Go dan driver mgo:

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

di mana hasilnya adalah contoh struct dari tipe yang dicari

Gunakan persamaan reguler yang cocok seperti di bawah ini. Huruf 'i' menunjukkan ketidakpekaan huruf besar-kecil.

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

Seperti Query akan seperti yang ditunjukkan di bawah ini

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

untuk 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]

Tampaknya ada alasan untuk menggunakan /regex_pattern/pola javascript maupun {'$regex': 'regex_pattern'}pola mongo . Lihat: Pembatasan Syntax MongoBD RegEx

Ini bukan tutorial RegEx yang lengkap, tetapi saya terinspirasi untuk menjalankan tes ini setelah melihat posting ambigu yang sangat terpilih di atas .

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

Jika Anda menggunakan Spring-Data Mongodb Anda bisa melakukan ini dengan cara ini:

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

Sebagai Mongo shell mendukung regex, itu sangat mungkin.

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

Jika kami ingin kueri tidak peka huruf besar-kecil, kami dapat menggunakan opsi "i", seperti yang ditunjukkan di bawah ini:

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

Jika Anda ingin pencarian 'Suka' di mongo maka Anda harus menggunakan $ regex dengan menggunakan query ini

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

untuk lebih lanjut Anda dapat membaca dokumentasi juga. https://docs.mongodb.com/manual/reference/operator/query/regex/

Gunakan pencarian substring agregasi (dengan indeks !!!):

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

Saya menemukan alat gratis untuk menerjemahkan pertanyaan MYSQL ke MongoDB. http://www.querymongo.com/ Saya memeriksa beberapa pertanyaan. seperti yang saya lihat hampir semuanya benar. Menurut itu, jawabannya adalah

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

MongoRegex telah ditinggalkan.
Gunakan 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()

Saat kami mencari pola string, selalu lebih baik menggunakan pola di atas karena ketika kami tidak yakin dengan huruf besar-kecil. Semoga itu bisa membantu !!!