Làm thế nào để truy vấn MongoDB với bản quyền như trực tuyến?

Tôi muốn truy vấn một cái gì đó với liketruy vấn của SQL :

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

Làm cách nào để tôi đạt được điều tương tự trong MongoDB? Tôi không thể tìm thấy một nhà điều hành liketrong tài liệu .

Đó sẽ phải là:

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

hoặc tương tự:

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

Bạn đang tìm kiếm thứ gì đó có chứa "m" ở đâu đó ( %toán tử ' ' của SQL tương đương với Regapi ' .*'), không phải thứ gì đó có "m" được neo vào đầu chuỗi.

lưu ý: mongodb sử dụng các biểu thức chính quy mạnh hơn "THÍCH" trong sql. Với các biểu thức thông thường, bạn có thể tạo bất kỳ mẫu nào mà bạn tưởng tượng.

Để biết thêm thông tin về các biểu thức thông thường, hãy tham khảo liên kết này 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%'

ra: paulo, patric

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

ra: paulo, patric

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

ra: bàn đạp

Trong

• PyMongo sử dụng Python
• Mongoose sử dụng Node.js
• Jongo , sử dụng Java
• mgo , sử dụng Go

bạn có thể làm:

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

Trong PHP, bạn có thể sử dụng mã sau đây:

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

Bạn sẽ sử dụng regex cho điều đó trong mongo.

ví dụ: db.users.find({"name": /^m/})

Đã có nhiều câu trả lời. Tôi đang đưa ra các loại yêu cầu và giải pháp khác nhau cho tìm kiếm chuỗi với regex.

Bạn có thể làm với regex có chứa từ tức là thích. Ngoài ra, bạn có thể sử dụng $options => icho trường hợp tìm kiếm không nhạy cảm

Chứa đựng string

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

Không stringchỉ chứa với regex

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

Trường hợp chính xác không nhạy cảm string

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

Bắt đầu với string

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

Kết thúc với string

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

Giữ nó như một dấu trang và một tài liệu tham khảo cho bất kỳ thay đổi nào khác mà bạn có thể cần.

Bạn có 2 sự lựa chọn:

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

hoặc là

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

Trong lần thứ hai, bạn có nhiều tùy chọn hơn, như "i" trong các tùy chọn để tìm cách sử dụng trường hợp không nhạy cảm. Và về "chuỗi", bạn có thể sử dụng như ". Chuỗi. " (% Chuỗi%) hoặc "chuỗi. *" (Chuỗi%) và ". * Chuỗi) (% chuỗi) chẳng hạn. Bạn có thể sử dụng biểu thức chính quy như bạn muốn.

Thưởng thức!

Nếu sử dụng node.js , nó nói rằng bạn có thể viết điều này:

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

Ngoài ra , bạn có thể viết điều này:

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

Bạn đã có câu trả lời nhưng để phù hợp với regex với trường hợp không nhạy cảm

Bạn có thể sử dụng truy vấn sau đây

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

Các itrong /m/ichỉ ra trường hợp vô hồn và .pretty()cung cấp một sản lượng khá hơn

Dành cho Mongoose trong Node.js

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

Bạn có thể sử dụng tính năng mới của 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"
    }
});

Trong dự án nodejs và sử dụng mongoose sử dụng Like query

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

Dành cho PHP mongo Like.
Tôi đã có một số vấn đề với php mongo như thế nào. tôi thấy rằng việc kết hợp các tham số regex sẽ giúp trong một số trường hợp PHP mongo tìm trường bắt đầu bằng . Tôi hình dung tôi sẽ đăng lên đây để đóng góp cho chủ đề phổ biến hơn

ví dụ

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)

Sử dụng mẫu chữ với các biến cũng hoạt động:

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

Với MongoDB Compass, bạn cần sử dụng cú pháp chế độ nghiêm ngặt, như sau:

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

(Trong MongoDB La bàn, điều quan trọng là bạn sử dụng "thay vì ')

Bạn có thể sử dụng câu lệnh where để xây dựng bất kỳ tập lệnh JS nào:

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

Tham khảo: http://docs.mongodb.org/manual/reference/operator/where/

Trong SQL, truy vấn ' like ' trông như thế này:

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

Trong bảng điều khiển MongoDB, nó trông như thế này:

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

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

Trong pretty()phương thức bổ sung sẽ ở tất cả những nơi tạo ra cấu trúc JSON được định dạng dễ đọc hơn.

Regex đắt tiền là quá trình.

Một cách khác là tạo một chỉ mục của văn bản và sau đó tìm kiếm nó bằng cách sử dụng $search.

Tạo một văn bản Chỉ mục các trường bạn muốn làm cho có thể tìm kiếm:

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

Tìm kiếm một chuỗi trong chỉ mục văn bản:

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

Trong Go và trình điều khiển mgo:

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

trong đó kết quả là thể hiện cấu trúc của kiểu tìm kiếm

Sử dụng biểu thức chính quy phù hợp như dưới đây. 'I' cho thấy trường hợp không nhạy cảm.

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

Like Query sẽ như dưới đây

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

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

Dường như có nhiều lý do để sử dụng cả /regex_pattern/mẫu javascript cũng như {'$regex': 'regex_pattern'}mẫu mongo . Xem: Giới hạn cú pháp MongoBD RegEx

Đây không phải là một hướng dẫn RegEx hoàn chỉnh, nhưng tôi được truyền cảm hứng để chạy các bài kiểm tra này sau khi thấy một bài viết mơ hồ được bình chọn cao ở trên .

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

Nếu bạn đang sử dụng Spring-Data Mongodb Bạn có thể làm điều này theo cách này:

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

Vì vỏ Mongo hỗ trợ regex, điều đó hoàn toàn có thể.

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

Nếu chúng tôi muốn truy vấn không phân biệt chữ hoa chữ thường, chúng tôi có thể sử dụng tùy chọn "i", như hiển thị bên dưới:

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

Nếu bạn muốn tìm kiếm 'Thích' trong mongo thì bạn nên sử dụng $ regex bằng cách sử dụng truy vấn này sẽ là

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

để biết thêm bạn có thể đọc tài liệu là tốt. https://docs.mongodb.com/manual/reference/operator/query/regex/

Sử dụng tìm kiếm chuỗi con tổng hợp (có chỉ mục !!!):

db.collection.aggregate([{
        $project : {
            fieldExists : {
                $indexOfBytes : ['$field', 'string']
            }
        }
    }, {
        $match : {
            fieldExists : {
                $gt : -1
            }
        }
    }, {
        $limit : 5
    }
]);

Chuỗi 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

Tôi tìm thấy một công cụ miễn phí để dịch các truy vấn MYSQL sang MongoDB. http://www.querymongo.com/ Tôi đã kiểm tra với một số truy vấn. như tôi thấy hầu hết tất cả đều đúng Theo đó, câu trả lời là

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

MongoRegex đã bị phản đối.
Sử dụng 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()

Khi chúng tôi đang tìm kiếm các mẫu chuỗi, luôn luôn tốt hơn là sử dụng mẫu trên như khi chúng tôi không chắc chắn về trường hợp. Mong rằng sẽ giúp !!!