如何用“喜欢”查询MongoDB？

时间：2010-07-22 03:19:22

标签： sql mongodb mongodb-query sql-like

我想用SQL的like查询查询：

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

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

44 个答案:

答案 0 :(得分：1678)

那必须是：

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

或类似的：

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

你正在寻找某处包含“m”的东西（SQL的“%”运算符等同于Regexp的“.*”），而不是“m”锚定到某个地方的东西字符串。

答案 1 :(得分：300)

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

答案 2 :(得分：232)

在

  • PyMongo 使用 Python
    • 使用 Node.js
  • Mongoose
  • Jongo ，使用 Java
  • mgo ，使用转到

你可以这样做：

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

答案 3 :(得分：79)

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

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

答案 4 :(得分：44)

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

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

答案 5 :(得分：38)

已经有很多答案了。我正在为正则表达式的字符串搜索提供不同类型的要求和解决方案。

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

将this保留为书签，并提供您可能需要的任何其他更改的参考。

答案 6 :(得分：27)

如果使用 node.js ，it表示您可以写下：

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

Also，你可以这样写：

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

答案 7 :(得分：22)

您有两个选择：

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

或

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

在第二个你有更多的选择，比如＆＃34;我＆＃34;在用于查找使用不区分大小写的选项中。 关于＆＃34;字符串＆＃34;，您可以使用类似＆＃34;。字符串。＆＃34; （％string％）或＆＃34; string。*＆＃34; （字符串％）和＆＃34;。*字符串）（％字符串）例如。您可以根据需要使用正则表达式。

享受！

答案 8 :(得分：17)

您已经得到了答案，但要将正则表达式与不区分大小写匹配

您可以使用以下查询

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

i中的/m/i表示不区分大小写，.pretty()提供更漂亮的输出

答案 9 :(得分：13)

对于Node.js中的Mongoose 

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

答案 10 :(得分：11)

对于PHP mongo赞。
我有几个与php mongo有关的问题。我发现连接正则表达式params在某些情况下有助PHP mongo find field starts with。我想我会发布在这里为更受欢迎的线程做贡献

e.g 

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)

答案 11 :(得分：10)

您可以使用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"
    }
});

答案 12 :(得分：9)

在 nodejs 项目中使用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);
            });

答案 13 :(得分：8)

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

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

（在MongoDB指南针中，使用"代替'非常重要）

答案 14 :(得分：8)

在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

在addion pretty()方法将在所有生成格式化JSON结构的地方更具可读性。

答案 15 :(得分：7)

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

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

参考：http://docs.mongodb.org/manual/reference/operator/where/

答案 16 :(得分：7)

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

答案 17 :(得分：7)

在Go和mgo驱动程序中：

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

其中result是搜索类型的结构实例

答案 18 :(得分：5)

正则表达是昂贵的过程。

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

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

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

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

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

答案 19 :(得分：5)

Like Query将如下所示

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

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

答案 20 :(得分：4)

如果你想在mongo中搜索'Like'那么你应该使用$ regex来使用这个查询

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

您可以阅读更多文档。 https://docs.mongodb.com/manual/reference/operator/query/regex/

答案 21 :(得分：4)

似乎有理由同时使用javascript /regex_pattern/模式以及mongo {'$regex': 'regex_pattern'}模式。请参阅：MongoBD RegEx Syntax Restrictions

这不是一个完整的RegEx教程，但在看到highly voted ambiguous post above之后，我受到启发，可以运行这些测试。

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

答案 22 :(得分：4)

由于Mongo shell支持正则表达式，这完全有可能。

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

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

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

答案 23 :(得分：4)

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

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

答案 24 :(得分：3)

我找到了一个将MYSQL查询翻译成MongoDB的免费工具。 http://www.querymongo.com/ 我查了几个问题。因为我看到几乎所有这些都是正确的。 据此，答案是

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

答案 25 :(得分：3)

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

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

与以下结果相同：

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

答案 26 :(得分：3)

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

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

如果字符串来自用户，则可能要在使用字符串之前对其进行转义。这样可以防止将来自用户的文字字符解释为正则表达式令牌。

例如，搜索字符串“ A”。 will also match如果未转义，则为“ 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") });

答案 27 :(得分：3)

使用聚合子字符串搜索（带索引!!!）：

A a1;
A a2 = std::move(a1);

答案 28 :(得分：2)

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

最简单的一个

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

更多详细信息可以在这里找到 https://docs.mongodb.com/manual/reference/operator/query/regex/

答案 29 :(得分：2)

MongoRegex已弃用。
使用MongoDB \ BSON \ Regex 

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

答案 30 :(得分：2)

字符串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

答案 31 :(得分：2)

将模板文字与变量一起使用也起作用：

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

答案 32 :(得分：1)

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

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

答案 33 :(得分：1)

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

答案 34 :(得分：1)

  • 一种找到结果的方式，等同于类似查询
db.collection.find({name:{'$regex' : 'string', '$options' : 'i'}})

我在不区分大小写的情况下用于获取数据的地方

  • 我们也可以得到结果的另一种方式
db.collection.find({"name":/aus/})

上面将提供名称中带有 aus 的澳大利亚名字的。

答案 35 :(得分：1)

使用 JavaScript 正则表达式

  • 用空格分割 name 字符串并制作一个单词数组
  • 映射到迭代循环并将字符串转换为名称的每个单词的正则表达式

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

结果：

[/My/, /Name/]

匹配字符串有两种情况，

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

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

db.users.find({ name: { $in: name } }); // name = [/My/, /Name/]
  1. $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
  ]
})

Playground

  1. $and： （类似于 $all 条件）一个文档应该包含所有单词
db.users.find({
  $and: [
    {
      $and: [
        { name: { $regex: "My" } },
        { name: { $regex: "Name" } }
      ]
    }
    // if you have multiple fields for search then repeat same block
  ]
})

Playground

答案 36 :(得分：0)

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

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

请务必使用*。

答案 37 :(得分：0)

root.right=insertion(root.right,7);

答案 38 :(得分：0)

这是从范例开始的命令

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

答案 39 :(得分：0)

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

$model = new MongoDB_DataObject();

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

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

OR：

$model = new MongoDB_DataObject('users);

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

$model->find();

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

答案 40 :(得分：0)

以防万一，有人正在寻找一个 SQL LIKE 类型的查询，用于保存字符串数组而不是字符串的键，这里是：

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

答案 41 :(得分：0)

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

<块引用>

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

或

<块引用>

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

在带有 @Query 注释的 Spring Boot 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 字段被替换为双引号字符串。所以在这些情况下不应该使用正斜杠 (/)！始终在搜索模式中使用双引号寻找模式！！例如，在 "^toron" or "^toron.*"

上使用 /^toron/ or /^toron.*/

答案 42 :(得分：0)

使用：

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' } },
        ],
      },
    );

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

答案 43 :(得分：0)

对于 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)
相关问题
最新问题