如何用“ like”查询MongoDB？

我想用SQL like查询来查询一些东西：

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

我如何在MongoDB中实现相同目标？我like在文档中找不到运算符。

那必须是：

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

或类似：

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

您正在寻找某处包含“ m”的东西（SQL的' %'运算符等效于Regexp的' .*'），而不是在字符串的开头锚定了“ m”的东西。

注意： mongodb使用的正则表达式比sql中的“ LIKE”更强大。使用正则表达式，您可以创建您想像的任何模式。

有关正则表达式的更多信息，请参阅此链接 https://developer.mozilla.org/zh-CN/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%'

出：paulo，patric

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

出：paulo，patric

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

出：佩德罗

在

• 使用Python的PyMongo
• 猫鼬使用Node.js
• Jongo，使用Java
• MGO，用围棋

你可以做：

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

在PHP中，您可以使用以下代码：

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

您可以在mongo中使用正则表达式。

例如： 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 mongo一样。
我有类似的PHP mongo的问题。我发现在某些情况下，连接正则表达式参数会有所帮助，PHP mongo find字段以开头。我想我会在这里发布以为更受欢迎的话题做贡献

例如

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结构，该结构更易读。

正则表达式是昂贵的过程。

另一种方法是创建文本索引，然后使用进行搜索$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)

其中result是所寻求类型的struct实例

使用正则表达式匹配，如下所示。“ 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]

似乎有理由同时使用javascript /regex_pattern/模式和mongo {'$regex': 'regex_pattern'}模式。请参阅：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 Shell支持正则表达式，因此这是完全可能的。

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

如果我们希望查询不区分大小写，则可以使用“ i”选项，如下所示：

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

如果您想在mongo中进行“赞”搜索，则应该使用$ 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
    }
]);

串Deepakparmar，dipak，parmar

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

Ans Deepakparmar

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

迪帕克 ans deepakparmar

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

帕尔玛 ans deepakparmar

我找到了一个免费的工具，可以将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()

当我们搜索字符串模式时，总是最好使用上面的模式，因为我们不确定大小写。希望有帮助！！！