.net Nest 操作elasticsearch

记录一点 Nest 的新的

    [ElasticsearchType(RelationName = "employee")]
    public class Employee
    {
        [Text(Name = "first_name", Norms = false)]
        public string FirstName { get; set; }

        [Text(Name = "last_name")]
        public string LastName { get; set; }

        [Number(DocValues = false, IgnoreMalformed = true, Coerce = true)]
        public int Salary { get; set; }

        [Date(Format = "MMddyyyy")]
        public DateTime Birthday { get; set; }

        [Boolean(NullValue = false, Store = true)]
        public bool IsManager { get; set; }
        [Text(Name = "office_hours")]
        public TimeSpan? OfficeHours { get; set; }

    }
    public class ElasticSearchHelper
    {
        static ElasticClient client;
        private ElasticSearchHelper()
        {
            var builder = new ConfigurationBuilder()
           .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
           .AddEnvironmentVariables();
            IConfiguration configuration = builder.Build();
            var ip = configuration["ESearchOption:DbToEsCon"];

            var node = new Uri(ip);
            //nest默认字段名首字母小写，如果要设置为与Model中一致，在创建client时按如下设置。（强烈建议使用该设置，避免造成字段不一致）
            var settings = new ConnectionSettings(node).DefaultFieldNameInferrer((name) => name);
            client = new ElasticClient(settings);
        }
        public static ElasticSearchHelper Instance { get; } = new ElasticSearchHelper();
        public static ElasticClient GetClient()
        {
            return client;
        }
        public void Index<TDocument>(TDocument document, Func<IndexDescriptor<TDocument>, IIndexRequest<TDocument>> selector) where TDocument : class
        {
            client.Index(document, selector);

        }
        public void IndexMany<T>(IEnumerable<T> objects, IndexName index = null) where T : class
        {
            client.IndexMany(objects, index);
        }
    }
    public class Program
    {
        public static void Main(string[] args)
        {

            var client = ElasticSearchHelper.GetClient();

            var r = client.Indices.Exists("test7");
            //删除索引
            client.Indices.Delete("test7");
            //client.Indices.Delete("test2");
            //client.Indices.Create("test3");
            //需要有默认index
            // client.IndexDocument(per);
            //基本配置
            IIndexState indexState = new IndexState()
            {
                Settings = new IndexSettings()
                {
                    NumberOfReplicas = 0,//副本数
                    NumberOfShards = 3//分片数
                }
            };
            //创建索引
            var restl = client.Indices.Create("test7", x => x.InitializeUsing(indexState).Map<Employee>(m => m.AutoMap()));

            var t = "";
            //创建并Mapping
            // client.CreateIndex("test-index3", p => p.InitializeUsing(indexState).Mappings(m => m.Map<VendorPriceInfo>(mp => mp.AutoMap())));

            //查询
            //var data = client.Search<A>(s => s.Index("testy").Size(500).Query(q => q.Term(t => t.authorid, "3")));
            //var result = client.Search<A>(s => s.Index("testy").Size(500).Query(q => q.Term(t => t.authorid, "3") && q.Range(r => r
            //                                     .Field(f => f.procount)
            //                                     .GreaterThanOrEquals(1)
            //                                     .LessThanOrEquals(5)
            //                              )));

            ////多条件查询
            //var mustQuerys = new List<Func<QueryContainerDescriptor<AuthorEs>, QueryContainer>>();
            //// 模糊查询
            //mustQuerys.Add(q => q.MatchPhrase(t => t.Field(x => x.nickname).Query("qq")));
            //mustQuerys.Add(q => q.Term(t => t.morestarid, 1));
            //mustQuerys.Add(mt => mt.Term(tm => tm.Field(fd => fd.moreageid).Value(1)));
            //mustQuerys.Add(q => q.Range(t => t.Field(f => f.birthday).GreaterThanOrEquals(1).LessThanOrEquals(2)));
            ////排序
            //Func<SortDescriptor<AuthorEs>, IPromise<IList<ISort>>> sortDesc = sd =>
            //{
            //    //根据分值排序
            //    // sd.Descending(SortSpecialField.Score);
            //    sd.Descending(d => d.totalfans);
            //    return sd;
            //};
            ////TrackTotalHits 符合条件的返回总数  es 的分页从0开始（不确定）
            //var docmsg = client.Search<AuthorEs>(b => b.Index("author").TrackTotalHits().Query(q => q.Bool(b => b.Must(mustQuerys))).Sort(sortDesc).From(0).Size(10));
            ////总数 
            //int count = (int)docmsg.Total;

            //List<A> la = new List<A>();
            //la.Add(new A { procount = 888, moreageid = 888, id = "3" });
            //la.Add(new A { procount = 222, moreageid = 222, id = "6" });
            ////批量添加存在会更新，不存在会添加是全部字段
            //client.IndexMany(la, "testy");
            ////单个更新某个字段 docasUpset=true 表示不存在也添加 false=不存在不添加
            //client.Update<object>(6, u => u.Index("testy").Doc(new { gender = 121 }).DocAsUpsert(true));
            //// client.Update<object>(6, u => u.Index("testy").Doc(new { gender = 121 }).DocAsUpsert(false));
            ////批量更新多个字段（将）
            //client.Bulk(b => b.Update<object>(u => u.Index("testy").Id("3").Doc(new { procount = 999, morageid = 444 })).Update<object>(u => u.Index("testy").Id("5").Doc(new { procount = 565, moreageid = 22 })));
            ////批量更新list类型
            //client.Bulk(b => b.UpdateMany(la, (b, u) => b.Id(u.id).Index("testy").Doc(new A { procount = u.procount, moreageid = u.moreageid })));

　　

        }
    }

 累加多个值

   //累加
            //var updateResponse = client.Update<object>(111111111111, u => u
            //     .Index("authorincr202105")
            //     .Script(s => s
            //         .Source("ctx._source.total_fans += params.count")
            //         .Lang("painless")
            //         .Params(p => p
            //             .Add("count", 4)
            //         )
            //     )
            // );

            //累加
            //var updateResponse = client.Bulk(b => b
            //.Update<object>(u => u
            //     .Index("authorincr202105")
            //     .Id("111111111111")
            //     .Script(s => s
            //         .Source("ctx._source.total_fans += params.count")
            //         .Lang("painless")
            //         .Params(p => p
            //             .Add("count", 4)
            //         )
            //     )
            // )
            //.Update<object>(u => u
            //     .Index("authorincr202105")
            //     .Id("222222222")
            //     .Script(s => s
            //         .Source("ctx._source.total_fans += params.count")
            //         .Lang("painless")
            //         .Params(p => p
            //             .Add("count", 45)
            //         )
            //     )
            // )
            //);

            List<UpAuthorIncrEs> list = new List<UpAuthorIncrEs>
            {
                new UpAuthorIncrEs() { secid = 111111111111, total_fans = 1000,total_fans_incr=-100},
                new UpAuthorIncrEs() { secid = 222222222, total_fans = 2000,total_fans_incr=-200,},
                new UpAuthorIncrEs() { secid = 33333333333, total_fans = 3000,total_fans_incr=-300}
            };
            var l = client.Bulk(b => b.UpdateMany(list, (b, u) => b.Id(u.secid.ToString()).Index("authorincr202105").Script(s => s
                                .Source("ctx._source.total_fans += params.total_fans;ctx._source.total_fans_incr = params.total_fans_incr")
                                .Lang("painless")
                                .Params(p => p
                                    .Add("total_fans", u.total_fans_incr)
                                    .Add("total_fans_incr", u.total_fans_incr)
                                )
                      )));

Nested 嵌套增加属性

/aweme/_mapping
{
  "properties": {
    "pro_ids": {
      "type": "nested",
      "properties": {
        "proid": {
          "type": "keyword"
        }
      }
    },
    "topics": {
      "type": "nested",
      "properties": {
        "huati": {
          "type": "keyword"
        }
      }
    }
  }
}
//设置默认值

/aweme/_update_by_query

{"script": {

"lang": "painless",
"source": "if (ctx._source.total_pro_share== null) {ctx._source.total_pro_share= 0}"
}
}

nested 查询

   var d = client.Search<AwemeEs>(b => b.Index("aweme2021").TrackTotalHits().Query(q => q.Nested(x => x.Path(x => x.pro_ids).Query(q => q.Terms(t => t.Field(f => f.pro_ids.FirstOrDefault().proid).Terms(new[] { "3484548520843809524", "645601590780", "3476963307917829978" }))))).From(0).Size(200));

nested 全部 修改

var l = client.Bulk(b => b.UpdateMany(d1, (b, u) => b.Id(u.awemeid).Index($"aweme2021").Script(s => s
            //                        .Source(
            //                                "ctx._source.pro_ids=params.proids;" +
            //                               "ctx._source.is_pro=params.count"
            //                                )
            //                                .Lang("painless")
            //                                .Params(p => p
            //                                    .Add("proids", u.proids)
            //                                    .Add("count", u.proids.Count)
            //                                )
            //                     )
            //                 ));

 聚合查询

一般进行聚合查询的时候，并不需要 _source 的东西，所以你在进行聚合查询是，可以在查询语句上指定 size=0，这样就只会返回 聚合 的结果，方式如下

var searchResponse = _client.Search<Project>(s => s
    .Size(0)  //显式指定为 0
    .Aggregations(aggs => aggs
        .Average("average_quantity", avg => avg.Field(p => p.Quantity))
        .Max("max_quantity", avg => avg.Field(p => p.Quantity))
        .Min("min_quantity", avg => avg.Field(p => p.Quantity))
    )
);

 分组聚合

 //var d = client.Search<AwemeIncrEs>(b => b.Index("awemeincr202107").TrackTotalHits().Query(x => x.Term(t => t.authorid, "104632838314")).Size(0).Aggregations(ag => ag.Sum("sum", sm => sm.Field(f => f.total_comment_incr))));
            //var lll = d.Aggregations.Average("sum").Value;

            var d2 = client.Search<AwemeIncrEs>(b => b.Index("awemeincr202107").TrackTotalHits().Query(x => x.Terms(t => t.Field(f => f.authorid).Terms(new[] { "104632838314", "104255897823" }))).Size(0).Aggregations(ag => ag.Terms("group", t => t.Field(fd => fd.authorid).Aggregations(agg => agg.Sum("total_comment_incr", sm => sm.Field(fd => fd.total_comment_incr)).Sum("total_share_incr", sm => sm.Field(fd => fd.total_share_incr))))));
            var mm = d2.Aggregations.Terms("group");
            foreach (var bucket in mm.Buckets)
            {
                var hitcid = bucket.AverageBucket("total_comment_incr").Value;//获取分组子集结果集
                                                                  //关键词高亮显示
            }