Как сделать запрос MongoDB с «лайком»?

Я хочу запросить что-то с likeзапросом SQL :

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

Как мне добиться того же в MongoDB? Я не могу найти оператора likeв документации .

Это должно быть:

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

или похожие:

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

Вы ищете что-то, что где-то содержит "m" (оператор SQL ' %' эквивалентен ' .*' регулярного выражения '), а не то, что "m" привязано к началу строки.

примечание: mongodb использует регулярные выражения, которые являются более мощными, чем "LIKE" в sql. С помощью регулярных выражений вы можете создать любой шаблон, который вы себе представляете.

Для получения дополнительной информации о регулярных выражениях обратитесь к этой ссылке 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%'

выход: Пауло, Патрик

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

выход: Пауло, Патрик

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

выход: педро

В

• PyMongo с использованием Python
• Мангуст используя Node.js
• Джонго , использующий Java
• MGO , используя Go

ты можешь сделать:

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

В PHP вы можете использовать следующий код:

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

Вы бы использовали регулярные выражения для этого в Монго.

например: db.users.find({"name": /^m/})

Там уже много ответов. Я даю различные типы требований и решений для поиска строк с помощью регулярных выражений.

Вы можете сделать с регулярным выражением, которые содержат слово, например, как. Также вы можете использовать $options => iдля поиска без учета регистра

Содержит string

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

Не содержит stringтолько регулярных выражений

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

Точный регистр нечувствителен string

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

Начать с string

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

Конец с string

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

Сохраните это как закладку и ссылку для любых других изменений, которые могут вам понадобиться.

У вас есть 2 варианта:

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

или

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

На втором у вас есть больше опций, например «i» в опциях, чтобы найти использование без учета регистра. А что касается «строки», вы можете использовать, например, «. String. » (% String%) или «string. *» (String%) и «. * String) (% string). Вы можете использовать регулярное выражение как пожелаете.

Наслаждайтесь!

Если используется node.js , он говорит, что вы можете написать это:

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

Также вы можете написать это:

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

Уже у вас есть ответы, но чтобы сопоставить регулярное выражение с учетом регистра

Вы можете использовать следующий запрос

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

iВ /m/iпоказывает случай нечувствительность и .pretty()обеспечивает более симпатичный выход

Для мангуста в Node.js

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

Вы можете использовать новую функцию 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"
    }
});

В проекте nodejs и использовании mongoose используйте запрос 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);
            });

Для PHP Монго Нравится.
У меня было несколько проблем с PHP как Монго. я обнаружил, что объединение параметров регулярных выражений помогает в некоторых ситуациях, когда поле поиска PHP mongo начинается с . Я решил опубликовать здесь, чтобы способствовать более популярной теме

например

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)

Использование литералов шаблона с переменными также работает:

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

С MongoDB Compass вам необходимо использовать синтаксис строгого режима, например:

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

(В MongoDB Compass важно использовать "вместо ')

Вы можете использовать оператор where для построения любого JS-скрипта:

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

Ссылка: http://docs.mongodb.org/manual/reference/operator/where/

В SQL запрос « like » выглядит так:

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

В консоли MongoDB это выглядит так:

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

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

В дополнение pretty()метод будет во всех местах, где производят форматированную структуру JSON, которая является более читаемой.

Regex - это дорогой процесс.

Другой способ - создать индекс текста, а затем выполнить поиск по нему $search.

Создайте текстовый указатель полей, которые вы хотите сделать доступным для поиска:

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

Поиск строки в текстовом индексе:

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

В Go и MGO драйвер:

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

где результат - экземпляр структуры искомого типа

Используйте совпадения регулярных выражений, как показано ниже. «I» показывает нечувствительность к регистру.

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

Как запрос будет как показано ниже

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

для 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]

Кажется, что есть причины использовать как /regex_pattern/шаблон javascript , так и {'$regex': 'regex_pattern'}шаблон mongo . Смотрите: Ограничения синтаксиса MongoBD RegEx

Это не полный учебник по RegEx, но я был вдохновлен на выполнение этих тестов после того, как увидел неоднозначный пост с высоким рейтингом выше .

> ['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, вы можете сделать это следующим образом:

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

Поскольку оболочка Mongo поддерживает регулярные выражения, это вполне возможно.

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

Если мы хотим, чтобы в запросе не учитывался регистр, мы можем использовать опцию «i», как показано ниже:

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

Если вы хотите поиск «Мне нравится» в Монго, используйте $ regex, используя этот запрос:

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

для более подробной информации вы также можете прочитать документацию. https://docs.mongodb.com/manual/reference/operator/query/regex/

Используйте поиск по подстроке агрегации (с индексом !!!):

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

Струнный дипакпармар, дипак, пармар

db.getCollection('yourdb').find({"name":/^dee/})

и дипакпармар

db.getCollection('yourdb').find({"name":/d/})

и дипакпармар, дипак

db.getCollection('yourdb').find({"name":/mar$/})

анс дипакпармар, пармар

Я нашел бесплатный инструмент для перевода запросов MYSQL в MongoDB. http://www.querymongo.com/ Я проверил несколько запросов. как я вижу, почти все они верны. В соответствии с этим, ответ

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

MongoRegex устарела.
Используйте 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()

Когда мы ищем строковые шаблоны, всегда лучше использовать вышеуказанный шаблон, когда мы не уверены в регистре. Надеюсь, это поможет!!!