如何用“like”查询 MongoDB

Question

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

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

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

Answer 1

那必须是：

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

或者，类似的：

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

您正在寻找某处包含“m”的东西（SQL 的 ' % ' 运算符相当于正则表达式'' .* '），而不是将“m”锚定到字符串开头的东西。

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

有关正则表达式的更多信息，请参阅正则表达式(MDN)。

Answer 2

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'

输出：佩德罗

Answer 3

在

• 使用Python 的PyMongo
• 猫鼬使用Node.js
• Jongo , 使用Java
• mgo ，使用Go

你可以做：

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

Answer 4

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

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

Answer 5

以下是使用正则表达式进行字符串搜索的不同类型的要求和解决方案。

您可以使用包含单词的正则表达式，即like 。 您也可以使用$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'}})

保留正则表达式备忘单作为书签，并作为您可能需要的任何其他更改的参考。

Answer 6

您将在 MongoDB 中使用正则表达式。

例如，

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

Answer 7

你有两个选择：

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

或者

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

对于第二个，您有更多选项，例如选项中的“i”以使用不区分大小写的方式查找。

而关于“字符串”，你可以使用像“ .string. ”（%string%），或者“string.*”（string%）和“.*string）（%string）”例如。你可以使用一个正则随心所欲地表达。

Answer 8

如果使用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') } );

Answer 9

您已经得到了答案，但要与不区分大小写的正则表达式匹配，您可以使用以下查询：

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

在i在/m/i表示不区分大小写和.pretty()提供了漂亮的输出。

Answer 10

对于 Node.js 中的猫鼬：

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

Answer 11

您可以使用 MongoDB 2.6 的新功能：

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

Answer 12

在Node.js项目中并使用Mongoose ，使用类似查询：

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

Answer 13

使用 MongoDB Compass，您需要使用严格模式语法，例如：

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

（在 MongoDB Compass 中，使用"而不是'很重要）

Answer 14

您可以使用where语句来构建任何 JavaScript 脚本：

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

参考： $where

Answer 15

对于 PHP mongo Like 。

我在使用 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)

Answer 16

使用带有变量的模板文字也有效：

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

Answer 17

在 Go 和mgo驱动程序中：

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

其中结果是抢手类型的结构体实例。

Answer 18

在 MongoDb 中，可以像使用MongoDb 引用运算符正则表达式（regex）一样使用。

对于相同的前。

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

MongoDb

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

    2) db.users.find({ "name": { $regex: new RegExp("m", 'i') } })

    3) db.users.find({ "name": { $regex:/m/i } })

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

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

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

MongoDb Any of Above with /^String/

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

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

MongoDb Any of Above with /String$/

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

Answer 19

在 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 结构，这样可读性更好。

Answer 20

正则表达式的处理成本很高。

另一种方法是创建文本索引，然后使用$search 。

创建要使其可搜索的字段的文本索引：

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

在文本索引中搜索字符串：

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

Answer 21

使用正则表达式匹配如下。 '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);

Answer 22

一个类似的查询如下所示：

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]

Answer 23

似乎有理由同时使用 JavaScript /regex_pattern/模式以及 MongoDB {'$regex': 'regex_pattern'}模式。 请参阅： MongoDB 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" }

Answer 24

如果你使用的是 Spring-Data MongoDB，你可以这样做：

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

Answer 25

String yourdb={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, 帕尔马

Answer 26

如果您有一个字符串变量，则必须将其转换为正则表达式，因此 MongoDB 将在其上使用 like 语句。

const name = req.query.title; //John
db.users.find({ "name": new Regex(name) });

与以下结果相同：

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

Answer 27

由于 MongoDB shell 支持正则表达式，这是完全可能的。

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

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

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

Answer 28

如果您想在 MongoDB 中进行“喜欢”搜索，那么您应该使用$regex 。 通过使用它，查询将是：

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

有关更多信息，您也可以阅读文档 - $regex

Answer 29

使用聚合子串搜索（带索引！！！）：

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

Answer 30

一种与类似查询等效的查找结果的方法：

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

其中i用于不区分大小写的获取数据。

我们也可以得到结果的另一种方式：

db.collection.find({"name":/aus/})

以上将提供名称中包含aus的结果。

Answer 31

MongoRegex 已被弃用。

使用MongoDB\\BSON\\Regex ：

$regex = new MongoDB\BSON\Regex ( '^m');
$cursor = $collection->find(array('users' => $regex));
//iterate through the cursor

Answer 32

您可以使用正则表达式进行查询：

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

如果字符串来自用户，也许您想在使用它之前对字符串进行转义。 这将防止来自用户的文字字符被解释为正则表达式标记。

例如，搜索字符串“A”。 如果没有转义，也将匹配“AB”。 在使用字符串之前，您可以使用简单的replace来对其进行转义。 我把它变成了一个重用的函数：

function textLike(str) {
  var escaped = str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
  return new RegExp(escaped, 'i');
}

所以现在，字符串变成了不区分大小写的模式，也匹配文字点。 例子：

>  textLike('A.');
<  /A\./i

现在我们准备好在旅途中生成正则表达式：

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

Answer 33

有多种方法可以做到这一点。

最简单的一个：

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

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

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

更多细节可以在$regex中找到。

Answer 34

使用 JavaScript 正则表达式

• 按空格分割name字符串并创建一个单词数组
• map 到一个迭代循环并将字符串转换为名称的每个单词的正则表达式

 let name = "My Name".split(" ").map(n => new RegExp(n)); console.log(name);

结果：

[/My/, /Name/]

匹配字符串有两种情况，

1. $in ：（类似于$or条件）

试试$in 表达式。 要在$in查询表达式中包含正则表达式，您只能使用 JavaScript 正则表达式对象（即/pattern/ ）。 例如：

db.users.find({ name: { $in: name } }); // name = [/My/, /Name/]

2. $all ：（类似于$and条件）一个文档应该包含所有单词

db.users.find({ name: { $all: name } }); // name = [/My/, /Name/]

使用嵌套$and和$or条件和$regex

匹配字符串有两种情况，

1. $or : (它类似于$in条件)

db.users.find({
  $or: [
    { name: { $regex: "My" } },
    { name: { $regex: "Name" } }
    // if you have multiple fields for search then repeat same block
  ]
})

操场

2. $and ：（类似于$all条件）一个文档应该包含所有单词

db.users.find({
  $and: [
    {
      $and: [
        { name: { $regex: "My" } },
        { name: { $regex: "Name" } }
      ]
    }
    // if you have multiple fields for search then repeat same block
  ]
})

操场

Answer 35

利用：

const indexSearch = await UserModel.find(
      { $text: { $search: filter } },
    );

    if (indexSearch.length) {
      return indexSearch;
    }
    return UserModel.find(
      {
        $or: [
          { firstName: { $regex: `^${filter}`, $options: 'i' } },
          { lastName: { $regex: `^${filter}`, $options: 'i' } },
          { middleName: { $regex: `^${filter}`, $options: 'i' } },
          { email: { $regex: `^${filter}`, $options: 'i' } },
        ],
      },
    );

我使用了正则表达式和“索引”的组合。

Answer 36

我想查询一些与SQL的like查询：

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

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

Answer 37

db.customer.find({"customerid": {"$regex": "CU_00000*", "$options": "i"}}).pretty()

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

Answer 38

如果您使用的是PHP，则可以使用MongoDB_DataObject包装器，如下所示：

$model = new MongoDB_DataObject();

$model->query("select * from users where name like '%m%'");

while($model->fetch()) {
    var_dump($model);
}

要么：

$model = new MongoDB_DataObject('users);

$model->whereAdd("name like '%m%'");

$model->find();

while($model->fetch()) {
    var_dump($model);
}

Answer 39

FullName如'last'，状态=='待定'在两个日期之间：

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

Answer 40

对于 Go 驱动程序：

filter := bson.M{
    "field_name": primitive.Regex{
        Pattern: keyword,
        Options: "",
    },
}
cursor, err := GetCollection().Find(ctx, filter)

在 $in 查询中使用正则表达式（MongoDB 文档： $in ）：

filter := bson.M{
    "field_name": bson.M{
        "$in": []primitive.Regex{
            {
                Pattern: keyword,
                Options: "",
            },
        }
    }
}
cursor, err := GetCollection().Find(ctx, filter)

Answer 41

>> db.car.distinct('name')
[ "honda", "tat", "tata", "tata3" ]

>> db.car.find({"name":/. *ta.* /})

Answer 42

您还可以使用通配符过滤器，如下所示：

{"query": { "wildcard": {"lookup_field":"search_string*"}}}

请务必使用* 。

Answer 43

这是使用“开始于”范例的命令：

db.customer.find({"customer_name" : { $regex : /^startswith/ }})

Answer 44

以防万一，有人正在寻找 SQL LIKE类型的查询，以获取包含字符串数组而不是字符串的键，这里是：

db.users.find({"name": {$in: [/.*m.*/]}})

Answer 45

前面的答案完美回答了有关核心 MongoDB 查询的问题。 但是当使用基于模式的搜索查询时，例如：

{"keywords":{ "$regex": "^toron.*"}}

或者

{“关键字”：{“$regex”：“^toron”}}

在带有 @Query 注释的Spring 引导JPA 存储库查询中，使用类似以下的查询：

@Query(value = "{ keyword : { $regex : ?0 }  }")
List<SomeResponse> findByKeywordContainingRegex(String keyword);

调用应该是以下之一：

List<SomeResponse> someResponseList =    someRepository.findByKeywordsContainingRegex("^toron");

List<SomeResponse> someResponseList =    someRepository.findByKeywordsContainingRegex("^toron.*");

但永远不要使用：

List<SomeResponse> someResponseList = someRepository.findByKeywordsContainingRegex("/^toron/");

List<SomeResponse> someResponseList =someRepository.findByKeywordsContainingRegex("/^toron.*/");

需要注意的重要一点：每次@Query语句中的?0字段都替换为双引号字符串。 因此，在这些情况下不应使用正斜杠 (/)，对于在搜索模式中使用双引号的模式，始终为 go！ 例如，在/^toron/ or /^toron.*/上使用"^toron" or "^toron.*"