仅显示 MongoDB 文本搜索的匹配字段

Question

我是 Mongo 的新手，想为 Web 前端实现文本搜索功能。我在“文本”索引的集合中添加了所有文本字段，因此搜索会在所有字段中找到匹配项。文件可能很重。

问题是当我收到整个匹配的文档而不仅仅是匹配的字段时。我只想随文档一起获取匹配的字段_id，因此我可以在 Web 预先输入中仅显示提示，当用户选择匹配项时，我可以通过_id.

有一个$project运算符，但问题是我不知道匹配项会出现在哪个文本字段中。

Answer 1

考虑了很久，我认为可以实现你想要的。但是，它不适合非常大的数据库，我还没有制定增量方法。它缺乏词干和停用词必须手动定义。

这个想法是使用 mapReduce 创建一个搜索词集合，其中包含对原始文档和搜索词来源字段的引用。然后，对于自动完成的实际查询是使用简单的聚合完成的，该聚合使用索引，因此应该相当快。

所以我们将使用以下三个文件

{
  "name" : "John F. Kennedy",
  "address" : "Kenson Street 1, 12345 Footown, TX, USA",
  "note" : "loves Kendo and Sushi"
}

和

{
  "name" : "Robert F. Kennedy",
  "address" : "High Street 1, 54321 Bartown, FL, USA",
  "note" : "loves Ethel and cigars"
}

和

{
  "name" : "Robert F. Sushi",
  "address" : "Sushi Street 1, 54321 Bartown, FL, USA",
  "note" : "loves Sushi and more Sushi"
}

在名为 的集合中textsearch。

map/reduce阶段

我们基本上要做的是，我们将处理三个字段之一中的每个单词，删除停用词和数字，并将每个单词与文档_id和出现的字段一起保存在中间表中。

注释的代码：

db.textsearch.mapReduce(
  function() {

    // We need to save this in a local var as per scoping problems
    var document = this;

    // You need to expand this according to your needs
    var stopwords = ["the","this","and","or"];

    // This denotes the fields which should be processed
    var fields = ["name","address","note"];

    // For each field...
    fields.forEach(

      function(field){

        // ... we split the field into single words...
        var words = (document[field]).split(" ");

        words.forEach(

          function(word){
            // ...and remove unwanted characters.
            // Please note that this regex may well need to be enhanced
            var cleaned = word.replace(/[;,.]/g,"")

            // Next we check...
            if(
              // ...wether the current word is in the stopwords list,...
              (stopwords.indexOf(word)>-1) ||

              // ...is either a float or an integer... 
              !(isNaN(parseInt(cleaned))) ||
              !(isNaN(parseFloat(cleaned))) ||

              // or is only one character.
              cleaned.length < 2
            )
            {
              // In any of those cases, we do not want to have the current word in our list.
              return
            }
              // Otherwise, we want to have the current word processed.
              // Note that we have to use a multikey id and a static field in order
              // to overcome one of MongoDB's mapReduce limitations:
              // it can not have multiple values assigned to a key.
              emit({'word':cleaned,'doc':document._id,'field':field},1)

          }
        )
      }
    )
  },
  function(key,values) {

    // We sum up each occurence of each word
    // in each field in every document...
    return Array.sum(values);
  },
    // ..and write the result to a collection
  {out: "searchtst" }
)

运行这将导致创建集合searchtst。如果它已经存在，它的所有内容都将被替换。

它看起来像这样：

{ "_id" : { "word" : "Bartown", "doc" : ObjectId("544b9811fd9270c1492f5835"), "field" : "address" }, "value" : 1 }
{ "_id" : { "word" : "Bartown", "doc" : ObjectId("544bb320fd9270c1492f583c"), "field" : "address" }, "value" : 1 }
{ "_id" : { "word" : "Ethel", "doc" : ObjectId("544b9811fd9270c1492f5835"), "field" : "note" }, "value" : 1 }
{ "_id" : { "word" : "FL", "doc" : ObjectId("544b9811fd9270c1492f5835"), "field" : "address" }, "value" : 1 }
{ "_id" : { "word" : "FL", "doc" : ObjectId("544bb320fd9270c1492f583c"), "field" : "address" }, "value" : 1 }
{ "_id" : { "word" : "Footown", "doc" : ObjectId("544b7e44fd9270c1492f5834"), "field" : "address" }, "value" : 1 }
[...]
{ "_id" : { "word" : "Sushi", "doc" : ObjectId("544bb320fd9270c1492f583c"), "field" : "name" }, "value" : 1 }
{ "_id" : { "word" : "Sushi", "doc" : ObjectId("544bb320fd9270c1492f583c"), "field" : "note" }, "value" : 2 }
[...]

这里有几点需要注意。首先，一个词可以多次出现，例如“FL”。但是，它可能在不同的文档中，就像这里的情况一样。另一方面，一个词也可以在单个文档的单个字段中多次出现。稍后我们将利用这一点。

其次，我们拥有所有字段，最显着的word是复合索引中的字段 for _id，这将使即将到来的查询非常快。但是，这也意味着该索引将非常大，并且 - 对于所有索引 - 往往会吃掉 RAM。

聚合阶段

所以我们减少了单词列表。现在我们查询（子）字符串。我们需要做的是找到到目前为止以用户输入的字符串开头的所有单词，返回与该字符串匹配的单词列表。为了能够做到这一点并以适合我们的形式获得结果，我们使用了聚合。

这种聚合应该非常快，因为所有需要查询的字段都是复合索引的一部分。

以下是用户输入字母时的带注释的聚合S：

db.searchtst.aggregate(
  // We match case insensitive ("i") as we want to prevent
  // typos to reduce our search results
  { $match:{"_id.word":/^S/i} },
  { $group:{
      // Here is where the magic happens:
      // we create a list of distinct words...
      _id:"$_id.word",
      occurrences:{
        // ...add each occurrence to an array...
        $push:{
          doc:"$_id.doc",
          field:"$_id.field"
        } 
      },
      // ...and add up all occurrences to a score
      // Note that this is optional and might be skipped
      // to speed up things, as we should have a covered query
      // when not accessing $value, though I am not too sure about that
      score:{$sum:"$value"}
    }
  },
  {
    // Optional. See above
    $sort:{_id:-1,score:1}
  }
)

这个查询的结果看起来像这样，应该是不言自明的：

{
  "_id" : "Sushi",
  "occurences" : [
    { "doc" : ObjectId("544b7e44fd9270c1492f5834"), "field" : "note" },
    { "doc" : ObjectId("544bb320fd9270c1492f583c"), "field" : "address" },
    { "doc" : ObjectId("544bb320fd9270c1492f583c"), "field" : "name" },
    { "doc" : ObjectId("544bb320fd9270c1492f583c"), "field" : "note" }
  ],
  "score" : 5
}
{
  "_id" : "Street",
  "occurences" : [
    { "doc" : ObjectId("544b7e44fd9270c1492f5834"), "field" : "address" },
    { "doc" : ObjectId("544b9811fd9270c1492f5835"), "field" : "address" },
    { "doc" : ObjectId("544bb320fd9270c1492f583c"), "field" : "address" }
  ],
  "score" : 3
}

Sushi 的得分为 5，因为 Sushi 一词在其中一份文档的注释字段中出现了两次。这是预期的行为。

虽然这可能是一个穷人的解决方案，需要针对无数可想象的用例进行优化，并且需要实现增量 mapReduce 才能在生产环境中发挥作用，但它按预期工作。嗯。

编辑

当然，可以删除$match阶段并$out在聚合阶段添加一个阶段，以便对结果进行预处理：

db.searchtst.aggregate(
  {
    $group:{
      _id:"$_id.word",
      occurences:{ $push:{doc:"$_id.doc",field:"$_id.field"}},
      score:{$sum:"$value"}
     }
   },{
     $out:"search"
   })

现在，我们可以查询结果search集合以加快处理速度。基本上你用实时结果换取速度。

编辑 2：如果采用预处理方法，searchtst聚合完成后应删除示例的集合，以节省磁盘空间和 - 更重要的 - 宝贵的 RAM。