Как запросить MongoDB с "как"?

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

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

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

+1065
22 июл. '10 в 3:19
источник поделиться
34 ответа
  • 1
  • 2

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

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

или, аналогично:

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

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

+1436
22 июл. '10 в 3:57
источник
db.users.insert({name: 'paulo'})
db.users.insert({name: 'patric'})
db.users.insert({name: 'pedro'})

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

out: paulo, patric

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

out: paulo, patric

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

out: pedro

+240
20 мая '14 в 13:26
источник

В

  • PyMongo с помощью Python
  • Mongoose, используя Node.js
  • Jongo, используя Java
  • mgo, используя Go

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

db.users.find({'name': {'$regex': 'sometext'}})
+190
07 окт. '12 в 17:07
источник

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

$collection->find(array('name'=> array('$regex' => 'm'));
+74
13 мая '11 в 8:36
источник

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

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

+42
22 июл. '10 в 3:48
источник

Если вы используете 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') } );
+25
09 мар. '14 в 6:11
источник

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

Вы можете делать с регулярным выражением, которое содержит слово i.e. Также вы можете использовать $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'}})

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

+22
11 авг. '16 в 15:39
источник

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

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

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

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

+14
21 нояб. '14 в 5:39
источник

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

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

или

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

Во втором случае у вас есть больше опций, например, "i" в параметрах, которые можно найти с помощью нечувствительности к регистру. И о "строке", вы можете использовать как ".string". (% string%) или строка "." (строка%) и строка ". *) (например, строка%). Вы можете использовать регулярное выражение, как хотите.

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

+13
26 апр. '17 в 2:48
источник

Для Mongoose в Node.js

db.users.find({'name': {'$regex': '.*sometext.*'}})
+11
10 нояб. '15 в 11:39
источник

Вы можете использовать новую функцию 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"
    }
});
+10
04 авг. '14 в 19:19
источник

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

например

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)
+9
17 сент. '14 в 20:20
источник

В проекте nodejs и используйте использование мангуста. Как запрос

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);
            });
+8
11 авг. '15 в 9:47
источник

Используйте регулярные выражения, как показано ниже. "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);
+6
11 дек. '15 в 7:35
источник

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

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

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

+6
05 сент. '13 в 14:53
источник

В SQL запрос как выглядит следующим образом:

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

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

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

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

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

+6
19 мар. '14 в 11:09
источник

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

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

где result является экземпляром struct искомого типа

+5
17 мар. '14 в 21:50
источник

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

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

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

+4
19 апр. '17 в 8:01
источник

Подобно запросу, как показано ниже

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]
+4
18 мая '15 в 9:55
источник

Если вы используете Spring -Data Mongodb, вы можете сделать это следующим образом:

String tagName = "m";
Query query = new Query();
query.limit(10);        
query.addCriteria(Criteria.where("tagName").regex(tagName));
+3
28 апр. '15 в 10:34
источник

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

Это не полный учебник 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" }
+3
10 янв. '17 в 19:39
источник

Если вы хотите "Like" искать в mongo, тогда вы должны пойти с $regex, используя этот запрос будет

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

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

+3
23 авг. '16 в 15:03
источник

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

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

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

db.users.findOne({"name" : /.*sometext.*/i});
+3
19 янв. '16 в 8:09
источник

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

db.users.find({
    "name": "%m%"
});
+2
06 дек. '16 в 5:07
источник

Regex - дорогостоящий процесс.

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

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

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

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

db.collection.find({
  '$text'=>{'$search': "The string"}
})
+2
16 мая '18 в 5:59
источник

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

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

+1
08 июн. '18 в 6:43
источник

FullName как "последний" со статусом == Ожидается между двумя датами:

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 == 'Ожидание' и orderId LIKE 'PHA876174:

db.orders.find({
     status:"Pending",
     orderId:/PHA876174/
     }).pretty();
+1
06 мая '17 в 8:38
источник
db.customer.find({"customerid": {"$regex": "CU_00000*", "$options": "i"}}).pretty()

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

+1
02 июн. '17 в 6:06
источник

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

db.collection.aggregate([{
        $project : {
            fieldExists : {
                $indexOfBytes : ['$field', 'string']
            }
        }
    }, {
        $match : {
            fieldExists : {
                $gt : -1
            }
        }
    }, {
        $limit : 5
    }
]);
+1
03 янв. '18 в 19:16
источник

MongoRegex устарел.
Используйте MongoDB\BSON\Regex

$regex = new MongoDB\BSON\Regex ( '^m');
$cursor = $collection->find(array('users' => $regex));
//iterate through the cursor
+1
27 янв. '17 в 20:06
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос