鉴于这些要求，我如何构建本文档的RavenDb where条款？

此问题基于以下问题

索引：

带分页的简单Where子句：

问题的实质是如何动态添加或删除字段以参与where子句

文件：

[Serializable]
public class Product
{
    public string AveWeight { get; set; }

    public string BrandName { get; set; }

    public string CasePack { get; set; }

    public string Catalog { get; set; }

    public decimal CatalogId { get; set; }

    public decimal CategoryId { get; set; }

    public string Info { get; set; }

    public bool IsOfflineSupplierItem { get; set; }

    public bool IsRebateItem { get; set; }

    public bool IsSpecialOrderItem { get; set; }

    public bool IsSpecialPriceItem { get; set; }

    public bool IsTieredPricingItem { get; set; }

    public string ItemNum { get; set; }

    public string ManufactureName { get; set; }

    public string ManufactureNum { get; set; }

    public decimal OffineSupplierId { get; set; }

    public string PackageRemarks { get; set; }

    public decimal Price { get; set; }

    public decimal PriceGroupId { get; set; }

    public decimal ProductId { get; set; }

    public string ProductName { get; set; }

    public int Quantity { get; set; }

    public string SupplierName { get; set; }

    public string UOM { get; set; }

    public string Upc { get; set; }

    public string Url { get; set; }

}

索引：

if (store.DatabaseCommands.GetIndex("Products_Index") == null)
{
    store.DatabaseCommands.PutIndex("Products_Index", new IndexDefinitionBuilder<Product>
    {
        Map = products => from p in products
                          select new { p.CatalogId, 
                                         p.HasPicture, 
                                         p.INFO2, 
                                         p.IsOfflineSupplierItem, 
                                         p.IsRebateItem, 
                                         p.IsSpecialOrderItem, 
                                         p.IsSpecialPriceItem, 
                                         p.IsTieredPricingItem, 
                                         p.Price },
        Indexes = 
        { 
            { x => x.INFO2, FieldIndexing.Analyzed }, 
            { x => x.CatalogId, FieldIndexing.Default},
            { x => x.HasPicture, FieldIndexing.Default},
            { x => x.IsOfflineSupplierItem, FieldIndexing.Default},
            { x => x.IsRebateItem, FieldIndexing.Default},
            { x => x.IsSpecialOrderItem, FieldIndexing.Default},
            { x => x.IsSpecialPriceItem, FieldIndexing.Default},
            { x => x.IsTieredPricingItem, FieldIndexing.Default},
            { x => x.Price, FieldIndexing.Default}
        }
    });
}

if（store.DatabaseCommands.GetIndex（“产品索引”）==null）
{
store.DatabaseCommands.PutIndex（“Products_Index”，新的IndexDefinitionBuilder
{
Map=products=>来自products中的p
选择新的{p.CatalogId，
p、 哈斯皮克，
p、 资讯2，
p、 IsofrinesSupplierItem，
p、 以色列，
p、 IsSpecialOrderItem，
p、 是特价商品，
p、 IsTieredPricingItem，
p、 价格}，
索引=
{ 
{x=>x.INFO2，FieldIndexing.Analyzed}，
{x=>x.CatalogId，fieldindex.Default}，
{x=>x.HasPicture，FieldIndexing.Default}，
{x=>x.IsoflineSupplierItem，FieldIndexing.Default}，
{x=>x.IsRebateItem，FieldIndexing.Default}，
{x=>x.IsSpecialOrderItem，FieldIndexing.Default}，
{x=>x.IsSpecialPriceItem，FieldIndexing.Default}，
{x=>x.istiredPricingItem，FieldIndexing.Default}，
{x=>x.Price，FieldIndexing.Default}
}
});
}

朴素Where子句

  string  t1 = "foo";
  bool    t2 = true;
  decimal t3 = 100m;

  products = DocumentSession.Query<Product>()
      .Statistics(out stats)
      .Where(p => p.INFO2.StartsWith(t1) && p.IsRebateItem == t2 && p.CatalogId = t3) 
      .OrderByField(columnToSortBy, columnToSortByAsc)
      .Skip(pageIndex * pageSize)
      .Take(pageSize)
      .ToList()
      ;

string t1=“foo”；
布尔t2=真；
十进制t3=100m；
products=DocumentSession.Query（）
.统计数据（统计数据）
.Where（p=>p.INFO2.StartsWith（t1）和&p.isrebatietem==t2和&p.CatalogId=t3）
.OrderByField（columnToSortBy、columnToSortByAsc）
.Skip（页面索引*页面大小）
.Take（页面大小）
托利斯先生（）
;

高级查询第一关

 var products = s.Advanced.LuceneQuery<Product>("Products")
    .WhereEquals("Catalog", "National Catalog")
    .ToList()
    ;

var products=s.Advanced.LuceneQuery（“产品”）
.WhereEquals（“目录”、“国家目录”）
托利斯先生（）
;

这会引发异常

Lucene.Net.dll中出现类型为“Lucene.Net.QueryParsers.QueryParser.LookaheadSuccess”的第一次意外异常 Lucene.Net.dll中发生了类型为“System.IO.IOException”的第一次意外异常

第二关（工程）

result=s.Advanced.LuceneQuery（“产品索引”）
其中（“CatalogId:（736275001）和HasPicture:（true）以及IsoflineSupplierItem:（false）”）
.ToArray（）；

第三关（也是最快的）

result=s.Advanced.LuceneQuery（“产品/索引”）
.统计数据（统计数据）
.WhereStartsWith（“信息2”、“墨水”）
.AndAlso（）
.WhereStartsWith（“信息2”、“笔”）
.AndAlso（）
.WhereEquals（“CatalogId”，736275001）
.AndAlso（）
.WhereEquals（“HasPicture”，真）
.AndAlso（）
.WhereEquals（“IsoflineSupplierItem”，false）
.AndAlso（）
.WhereEquals（“IsRebateItem”，false）
.AndAlso（）
.WhereEquals（“IsSpecialOrderItem”，false）
.AndAlso（）
.WhereEquals（“IsSpecialPriceItem”，false）
.ToArray（）
;

如果要动态执行此操作，可以使用DocumentSession.Advanced.LuceneQuery，它允许您传递字符串作为索引的属性名。

---

这样，您就不必处理强类型问题。

如果GetIndex==null，则不要这样做，然后PutIndex-它不会处理索引更改。看见

 result = s.Advanced.LuceneQuery<Product>("Products_Index")
 .Where("CatalogId:(736275001) AND HasPicture:(true) AND IsOfflineSupplierItem:(false)")
 .ToArray();

result = s.Advanced.LuceneQuery<Product>("Products/Index")
    .Statistics(out stats)
    .WhereStartsWith("INFO2", "ink")
    .AndAlso()
    .WhereStartsWith("INFO2", "pen")
    .AndAlso()
    .WhereEquals("CatalogId", 736275001)
    .AndAlso()
    .WhereEquals("HasPicture", true)
    .AndAlso()
    .WhereEquals("IsOfflineSupplierItem", false)
    .AndAlso()
    .WhereEquals("IsRebateItem", false)
    .AndAlso()
    .WhereEquals("IsSpecialOrderItem", false)
    .AndAlso()
    .WhereEquals("IsSpecialPriceItem", false)
    .ToArray()
    ;