C# 使用嵌套和弹性搜索创建到文档字段的analyzer映射_C#_<img Src="//i.stack.imgur.com/RUiNP.png" Height="16" Width="18" Alt="" Class="sponsor Tag Img">elasticsearch_Nest

C# 使用嵌套和弹性搜索创建到文档字段的analyzer映射

c# nest

C# 使用嵌套和弹性搜索创建到文档字段的analyzer映射,c#,elasticsearch,nest,C#,elasticsearch,Nest,我正在使用nest0.11.0.0和示例代码blow。此代码成功创建索引，但我的搜索查询不起作用。我希望能够搜索带有破折号的产品代码，如“14-KP-OM-00368”。我错过了什么 using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using ElasticSearchSample.Data; using Nest; namespace ElasticSea

我正在使用nest0.11.0.0和示例代码blow。此代码成功创建索引，但我的搜索查询不起作用。我希望能够搜索带有破折号的产品代码，如“14-KP-OM-00368”。我错过了什么

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using ElasticSearchSample.Data;
using Nest;

namespace ElasticSearchSample
{
    class Program
    {
        static void Main(string[] args)
        {
            const string keyName = "products";
            var typeName = typeof(ProductEntity).ToString();

            var setting = new ConnectionSettings(new Uri("http://localhost:3330/"));
            setting.SetDefaultIndex("products");
            var elasticClient = new ElasticClient(setting);

            var products = GetProducts();

            foreach (var product in products)
            {
                elasticClient.MapFromAttributes<ProductEntity>();
                var settings = new IndexSettings { NumberOfReplicas = 0, NumberOfShards = 5 };

                settings.Analysis.Tokenizers.Add("keyword", new KeywordTokenizer());
                settings.Analysis.Tokenizers.Add("standard", new StandardTokenizer());
                settings.Analysis.TokenFilters.Add("standard", new StandardTokenFilter());
                settings.Analysis.TokenFilters.Add("lowercase", new LowercaseTokenFilter());
                settings.Analysis.TokenFilters.Add("stop", new StopTokenFilter());
                settings.Analysis.TokenFilters.Add("asciifolding", new AsciiFoldingTokenFilter());
                settings.Analysis.TokenFilters.Add("word_delimiter", new WordDelimiterTokenFilter());

                if (!elasticClient.IndexExists(keyName).Exists)
                    elasticClient.CreateIndex(keyName, settings);

                elasticClient.DeleteById(keyName, typeName, product.Identifier.ToString(), new DeleteParameters { Refresh = true });

                elasticClient.Index(product, keyName, typeName, product.Identifier.ToString(), new IndexParameters { Refresh = true });
            }

            var sp1 = Stopwatch.StartNew();

            //Search part 
            var result = elasticClient.Search<ProductEntity>(body => body.Type(typeName)
                                                                            .Fields(f => f.ProductCode).Query(q => q
                                                                            .Term(f => f.ProductCode.ToLower(), "14 kp om 01567", 2.0)));

            // I searched via lower case char without dash, with dash but no luck
            // but I want want to search with dash

            Console.WriteLine("ES Results : {0:#,#} documents in {1:#,#}ms: {2:#,#.##}: docs/ms\n\n", result.Documents.Count(), sp1.ElapsedMilliseconds, result.Documents.Count() / (double)sp1.ElapsedMilliseconds);
            Console.ReadLine();
        }

        public static List<ProductEntity> GetProducts()
        {
            var list = new List<ProductEntity> {
                                                        new ProductEntity {CreatedDate = new DateTime(2013, 6, 25),Identifier = Guid.NewGuid(),IsActive = true,ProductCode = "14-KP-OM-00368", ProductName = "Şemsiye", SortOrder = 1}, 
                                                        new ProductEntity {CreatedDate = new DateTime(2013, 6, 25),Identifier = Guid.NewGuid(),IsActive = true,ProductCode = "14-KP-OM-01567", ProductName = "Çeşme",SortOrder = 2 }
                                                    };
            return list;
        }
    }
}

namespace ElasticSearchSample.Data
{
    [ElasticType(Name = "ElasticSearchSample.Data.ProductEntity", SearchAnalyzer = "full_name", IndexAnalyzer = "partial_name", DateDetection = true, NumericDetection = true, DynamicDateFormats = new[] { "dateOptionalTime", "yyyy-MM-dd HH:mm:ss Z||yyyy-MM-dd Z" })]
    public class ProductEntity
    {
        [ElasticProperty(Type = FieldType.string_type, Index = FieldIndexOption.analyzed)]
        public Guid Identifier { get; set; }

        [ElasticProperty(Type = FieldType.string_type, Index = FieldIndexOption.analyzed)]
        public string ProductCode { get; set; }

        [ElasticProperty(Type = FieldType.string_type, Index = FieldIndexOption.analyzed)]
        public string ProductName { get; set; }

        [ElasticProperty(Type = FieldType.boolean_type, Index = FieldIndexOption.analyzed)]
        public bool IsActive { get; set; }

        [ElasticProperty(Type = FieldType.integer_type, Index = FieldIndexOption.analyzed)]
        public int? SortOrder { get; set; }

        [ElasticProperty(Type = FieldType.date_type, Index = FieldIndexOption.analyzed)]
        public DateTime CreatedDate { get; set; }
    }

}

使用系统；
使用System.Collections.Generic；
使用系统诊断；
使用System.Linq；
使用ElasticSearchSample.数据；
利用鸟巢；
命名空间ElasticSearchSample
{
班级计划
{
静态void Main（字符串[]参数）
{
const string keyName=“产品”；
var typeName=typeof（ProductEntity）.ToString（）；
var设置=新连接设置（新Uri（“http://localhost:3330/"));
setting.SetDefaultIndex（“产品”）；
var elasticClient=新的elasticClient（设置）；
var products=GetProducts（）；
foreach（产品中的var产品）
{
elasticClient.MapFromAttributes（）；
var设置=新索引设置{NumberOfReplicas=0，NumberOfShards=5}；
settings.Analysis.Tokenizers.Add（“关键字”，new KeywordTokenizer（））；
settings.Analysis.Tokenizers.Add（“标准”，新的StandardTokenizer（））；
settings.Analysis.TokenFilters.Add（“标准”，新的StandardTokenFilter（））；
settings.Analysis.TokenFilters.Add（“lowercase”，新的LowercaseTokenFilter（））；
settings.Analysis.TokenFilters.Add（“stop”，新的stoptokefilter（））；
settings.Analysis.TokenFilters.Add（“asciifolding”，new-AsciiFoldingTokenFilter（））；
settings.Analysis.TokenFilters.Add（“word_delimiter”，newworddelimiterTokenFilter（））；
如果（！elasticClient.indexists（keyName.Exists）
elasticClient.CreateIndex（键名、设置）；
elasticClient.DeleteById（keyName、typeName、product.Identifier.ToString（），新的DeleteParameters{Refresh=true}）；
elasticClient.Index（product，keyName，typeName，product.Identifier.ToString（），新的IndexParameters{Refresh=true}）；
}
var sp1=Stopwatch.StartNew（）；
//搜索部分
var result=elasticClient.Search（body=>body.Type（typeName）
.Fields（f=>f.ProductCode）.Query（q=>q
.术语（f=>f.ProductCode.ToLower（），“14 kp om 01567”，2.0））；
//我通过小写字符搜索，没有破折号，有破折号但没有运气
//但我想用dash搜索
WriteLine（“ES结果：{0:#，{1:#，}ms中的{0:#，}文档：{2:#，}.#}文档/ms\n\n”，result.documents.Count（），sp1.elapsedmillseconds，result.documents.Count（）/（double）sp1.elapsedmillseconds）；
Console.ReadLine（）；
}
公共静态列表GetProducts（）
{
变量列表=新列表{
新产品实体{CreatedDate=new DateTime（2013,6,25），Identifier=Guid.NewGuid（），IsActive=true，ProductCode=“14-KP-OM-00368”，ProductName=“Şemsiye”，SortOrder=1}，
新产品实体{CreatedDate=new DateTime（2013,6,25），Identifier=Guid.NewGuid（），IsActive=true，ProductCode=“14-KP-OM-01567”，ProductName=“şme”，SortOrder=2}
};
退货清单；
}
}
}
命名空间ElasticSearchSample.Data
{
[ElasticType（Name=“ElasticSearchSample.Data.ProductEntity”，SearchAnalyzer=“full_Name”，IndexAnalyzer=“partial_Name”，DateDetection=true，NumericDetection=true，DynamicDateFormats=new[]{“dateOptionalTime”，“yyyy-MM-dd HH:MM:ss Z | | yyyy-MM-dd Z”}]
公共类ProductEntity
{
[ElasticProperty（Type=FieldType.string\u Type，Index=FieldIndexOption.analysisted）]
公共Guid标识符{get；set；}
[ElasticProperty（Type=FieldType.string\u Type，Index=FieldIndexOption.analysisted）]
公共字符串ProductCode{get；set；}
[ElasticProperty（Type=FieldType.string\u Type，Index=FieldIndexOption.analysisted）]
公共字符串ProductName{get；set；}
[ElasticProperty（类型=FieldType.boolean_类型，索引=FieldIndexOption.Analysis）]
公共bool IsActive{get；set；}
[ElasticProperty（类型=FieldType.integer\u类型，索引=FieldIndexOption.Analysis）]
公共int？排序器{get；set；}
[ElasticProperty（类型=FieldType.date\u类型，索引=FieldIndexOption.Analysis）]
公共日期时间CreatedDate{get；set；}
}
}

您正在创建分析器，但您从未告诉elasticsearch产品类型使用什么，因此将使用默认分析器，该分析器将分解为以下几部分：

14-KP-OM-00368

：

```
14
```
```
kp
```
```
om
```
```
00368
```

如果您随后对

14 kp om 00368

发出术语查询，它将无法找到它，因为它试图将其作为单个术语，而上一个列表不包含该术语

您要执行以下操作：

client.CreateIndex(keyName, c => c
    .NumberOfReplicas(0)
    .NumberOfShards(1)
    .Settings(s=>s //just as an example
        .Add("merge.policy.merge_factor","10")
        .Add("search.slowlog.threshold.fetch.warn", "1s")
    )   
    .AddMapping<ProductEntity>(m => m
        //this will explicitly map all the properties it finds
        //so es knows in advance Date's are dates, ints are int's
        //This will also apply ElasticType attributes
        .MapFromAttributes()
        //here we inform es our propertyType field is to be analyzed
        //using the keyword analyzers
        .Properties(props => props
            .String(s => s
                .Name(p => p.PropertyType)
                .IndexAnalyzer("keyword")
            )
        )
    )
    //just to show you can map more types at once
    .AddMapping<Person>(m => m.MapFromAttributes()) 
);

client.CreateIndex（keyName，c=>c
.numberofreplications（0）
.NumberOfShard（1）
.Settings（s=>s//仅作为示例
.Add（“merge.policy.merge\u factor”，“10”）
.Add（“search.slowlog.threshold.fetch.warn”，“1s”）
)   
.AddMapping（m=>m
//这将显式映射它找到的所有属性
//所以es预先知道日期是日期，整数是整数
//这也将应用ElasticType属性
.MapFromAttributes（）
//在此，我们通知es我们的propertyType字段将被分析
//使用关键字分析器
.Properties（props=>props
.String（s=>s
.Name（p=>p.property