Question

为了概念验证，我已经将大约5400万条记录加载到mongodb中。目的是调查mongodb的查询速度。

我使用以下类来存储数据：

[BsonDiscriminator("Part", Required = true)]
public class Part
{
   [BsonId]
    public ObjectId Id { get; set; }
   [BsonElement("pgc")]
   public int PartGroupCode { get; set; }
   [BsonElement("sc")]
   public int SupplierCode { get; set; }
   [BsonElement("ref")]
   public string ReferenceNumber { get; set; }

   [BsonElement("oem"), BsonIgnoreIfNull]
   public List<OemReference> OemReferences { get; set; }

   [BsonElement("alt"), BsonIgnoreIfNull]
   public List<AltReference> AltReferences { get; set; }

   [BsonElement("crs"), BsonIgnoreIfNull]
   public List<CrossReference> CrossReferences { get; set; }

   [BsonElement("old"), BsonIgnoreIfNull]
   public List<FormerReference> FormerReferences { get; set; }

   [BsonElement("sub"), BsonIgnoreIfNull]
   public List<SubPartReference> SubPartReferences { get; set; }
}

我创建了以下索引：

ref，sc，pgc
oem.refoem上升指数
alt.refalt上升指数
crs.refcrs上升指数
old.refold上升指数
sub.refsub

我执行以下查询来测试性能：

var searchValue = "345";
var start = DateTime.Now;
var result1 = collection.AsQueryable<Part>().OfType<Part>().Where(part => part.ReferenceNumber == searchValue);
long count = result1.Count();
var finish = DateTime.Now;

start = DateTime.Now;
var result2 = collection.AsQueryable<Part>().OfType<Part>().Where(part =>
    part.ReferenceNumber.Equals(searchValue) ||
    part.OemReferences.Any(oem => oem.ReferenceNumber.Equals(searchValue)) ||
    part.AltReferences.Any(alt => alt.ReferenceNumber.Equals(searchValue)) ||
    part.CrossReferences.Any(crs => crs.ReferenceNumber.Equals(searchValue)) ||
    part.FormerReferences.Any(old => old.ReferenceNumber.Equals(searchValue))
    );
count = result2.Count();
finish = DateTime.Now;

start = DateTime.Now;
var result3 = collection.AsQueryable<Part>().OfType<Part>().Where(part =>
    part.ReferenceNumber.StartsWith(searchValue) ||
    part.OemReferences.Any(oem => oem.ReferenceNumber.StartsWith(searchValue)) ||
    part.AltReferences.Any(alt => alt.ReferenceNumber.StartsWith(searchValue)) ||
    part.CrossReferences.Any(crs => crs.ReferenceNumber.StartsWith(searchValue)) ||
    part.FormerReferences.Any(old => old.ReferenceNumber.StartsWith(searchValue))
    );
count = result3.Count();
finish = DateTime.Now;

var regex = new Regex("^345"); //StartsWith regex
start = DateTime.Now;
var result4 = collection.AsQueryable<Part>().OfType<Part>().Where(part =>
    regex.IsMatch(part.ReferenceNumber) ||
    part.OemReferences.Any(oem => regex.IsMatch(oem.ReferenceNumber)) ||
    part.AltReferences.Any(alt => regex.IsMatch(alt.ReferenceNumber)) ||
    part.CrossReferences.Any(crs => regex.IsMatch(crs.ReferenceNumber)) ||
    part.FormerReferences.Any(old => regex.IsMatch(old.ReferenceNumber))
    );
count = result4.Count();
finish = DateTime.Now;

结果不是我预期的结果：

在345上搜索1结果：3条记录（00：00：00.3635937）
在345上搜索2结果：58条记录（00：00：00.0671566）
在345上搜索3结果：6189条记录（00：01：17.6638459）
在345上搜索4结果：6189条记录（00：01：17.0727802）

为什么StartsWith查询（3和4）要慢得多？ StartsWith查询性能是决定或决定。

我创建了错误的索引吗？任何帮助表示赞赏。

将mongodb与10gen C＃驱动程序一起使用

更新：查询从Linq转换为MongoDB查询的方式对于性能非常重要。我再次使用Query对象构建相同的查询（如3和4）：

var query5 = Query.And(
    Query.EQ("_t", "Part"),
    Query.Or(
    Query.Matches("ref", "^345"),
    Query.Matches("oem.refoem", "^345"),
    Query.Matches("alt.refalt", "^345"),
    Query.Matches("crs.refcrs", "^345"),
    Query.Matches("old.refold", "^345")));

start = DateTime.Now;
var result5 = collection.FindAs<Part>(query5);
count = result5.Count();
finish = DateTime.Now;

此查询的结果将在00：00：00.4522972

中返回

查询翻译为 command: { count: "PSG", query: { _t: "Part", $or: [ { ref: /^345/ }, { oem.refoem: /^345/ }, { alt.refalt: /^345/ }, { crs.refcrs: /^345/ }, { old.refold: /^345/ } ] } }

与查询3和4相比，差异很大： command: { count: "PSG", query: { _t: "Part", $or: [ { ref: /^345/ }, { oem: { $elemMatch: { refoem: /^345/ } } }, { alt: { $elemMatch: { refalt: /^345/ } } }, { crs: { $elemMatch: { refcrs: /^345/ } } }, { old: { $elemMatch: { refold: /^345/ } } } ] } }

那么为什么查询3和4没有使用索引？

Answer 1

来自index documentation：

每个查询（包括更新操作）都使用一个且仅使用一个索引。

换句话说，MongoDB doesn't support index intersection。因此，创建大量索引是没有意义的，除非有查询仅使用此索引和此索引。此外，请确保您在此处调用正确的Count()方法。如果你调用linq-to-object扩展名（IEnumerable＆＃39; Count()扩展名而不是MongoCursor＆＃39; Count，那么它实际上必须获取并保湿所有物体。）

将这些内容放在一个mutli-key index中可能更容易：

{ 
    "References" : [ { id: new ObjectId("..."), "_t" : "OemReference", ... }, 
                     { id: new ObjectId("..."), "_t" : "CrossReferences", ...} ],
    ...
}

其中References.id被编入索引。现在，查询db.foo.find({"References.id" : new ObjectId("...")})将自动搜索引用数组中的任何匹配项。由于我假设必须区分不同类型的引用，因此使用鉴别器是有意义的，因此驱动程序可以支持多态反序列化。在C＃中，您将此声明为

[BsonDiscriminator(Required=true)]
[BsonKnownTypes(typeof(OemReference), typeof(...), ...)]
class Reference { ... }

class OemReference : Reference { ... }

驱动程序将自动序列化名为_t的字段中的类型名称。如果需要，可以根据您的需要调整该行为。

另请注意，缩短属性名称会降低存储要求，但不会影响索引大小。

具有starts-with的性能mongodb查询

1 个答案: