Question

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

问题在于，当我收到整个匹配的文档而不仅仅是匹配的字段时。我想只获得匹配的字段以及文档_id，所以我只能在Web类型中提示一个提示，当用户选择匹配时，我可以通过{{加载整个文档1}}。

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

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的集合中。

地图/缩小阶段

我们基本上做的是，我们将处理三个字段之一中的每个单词，删除单词和数字，并使用文档_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 }
[...]

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

其次，我们拥有所有字段，最明显的是word的复合索引中的_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
}

寿司的5分来自于寿司在其中一个文件的注释字段中出现两次这一事实。这是预期的行为。

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

修改

当然，可以放弃$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。

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

1 个答案:

地图/缩小阶段

聚合阶段