zoukankan      html  css  js  c++  java
  • Elasticsearch NEST – Examples for mapping between Query and C#

    Elasticsearch NEST – Examples for mapping between Query and C#

    During my training with Elasticsearch I would like to map a query with GET/POST method to C# syntax of NEST. It’s very helpful for me to see how NEST composes its internal queries and sends to Elasticsearch server. I just post my sample project here, maybe it’ll help you too.

    1. Indexing Employee Documents

    PUT /megacorp/employee/1
    {
      "about": "I love to go rock climbing",
      "age": 25,
      "firstName": "John",
      "id": 1,
      "interests": [
        "sports",
        "music"
      ],
      "lastName": "Smith"
    }
    Employee employee = new Employee()
    {
        Id = 1,
        FirstName = "John",
        LastName = "Smith",
        Age = 25,
        About = "I love to go rock climbing",
        Interests = new List<string>() { "sports", "music" }
    };
    await client.IndexAsync(employee);

    2. Retrieving a Document

    GET /megacorp/employee/1
    {
      "_index" : "megacorp",
      "_type" : "employee",
      "_id" : "1",
      "_version" : 9,
      "found" : true,
      "_source" : {
        "about" : "I love to go rock climbing",
        "age" : 25,
        "firstName" : "John",
        "id" : 1,
        "interests" : [ "sports", "music" ],
        "lastName" : "Smith"
      }
    }
    public async Task<T> GetById(int id)
    {
        var response = await client.GetAsync<T>(new DocumentPath<T>(id), g => g.Index(defaultIndex).Type(defaultType));
        return response.Source;
    }

    3. Search Lite

    We will search for all employees, with this request

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {}
    public async Task<IEnumerable<T>> SearchAsync()
    {
        var response = await client.SearchAsync<T>(s => s.Type(defaultType));
        return response.Documents;
    }

    4. Search with Query DSL

    We can represent the search for all Smiths like so

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
        "query": {
        "match": {
            "lastName": {
                "query": "Smith"
            }
        }
        }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Query(q => q.Match(m => m.Field(f => f.LastName).Query("Smith"))));
        Result = result.Documents;
    }

    5. Search with Query String

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
      "query": {
        "query_string": {
          "query": "Smith",
          "fields": [
            "lastName"
          ]
        }
      }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Query(q => q.QueryString(qs =>
                        qs.Fields(f => f.Field(fi => fi.LastName))
                            .Query("Smith"))));
        Result = result.Documents;
    }

    6. More-Complicated Searches

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "lastName": {
                  "query": "smith"
                }
              }
            }
          ],
          "filter": [
            {
              "range": {
                "age": {
                  "gt": 30.0
                }
              }
            }
          ]
        }
      }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Query(q => q.Bool(b =>
                        b.Filter(f =>
                            f.Range(r =>
                                r.Field(fi => fi.Age).GreaterThan(30)))
                       .Must(m =>
                            m.Match(ma =>
                                ma.Field(fie => fie.LastName).Query("smith")))
                        )));
        Result = result.Documents;
    }

    7. Full-Text Search

    We are going to search for all employees who enjoy “rock climbing”, “rock” or “climbing”.

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
      "query": {
        "match": {
          "about": {
            "query": "rock climbing"
          }
        }
      }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Query(q =>
                        q.Match(m =>
                            m.Field(f => f.About).Query("rock climbing"))
                       ));
        Result = result.Documents;
    }

    8. Phrase Search

    Finding individual words in a field is all well and good, but sometimes you want to
    match exact sequences of words or phrases. For instance, we could perform a query
    that will match only employee records that contain both “rock” and “climbing” and
    that display the words are next to each other in the phrase “rock climbing.”

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
      "query": {
        "match": {
          "about": {
            "type": "phrase",
            "query": "rock climbing"
          }
        }
      }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Query(q =>
                        q.MatchPhrase(m =>
                            m.Field(f => f.About).Query("rock climbing"))
                       ));
        Result = result.Documents;
    }

    9. Highlighting Our Searches

    Many applications like to highlight snippets of text from each search result so the user
    can see why the document matched the query

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
      "highlight": {
        "fields": {
          "about": {}
        }
      },
      "query": {
        "match": {
          "about": {
            "type": "phrase",
            "query": "rock climbing"
          }
        }
      }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Query(q =>
                        q.MatchPhrase(m =>
                            m.Field(f => f.About).Query("rock climbing")))
                    .Highlight(h => h.Fields(fi => fi.Field(fie => fie.About)))
            );
        Result = result.Hits;
    }

    10. Analytics

    Let’s find the most popular interests enjoyed by our employees

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
      "aggs": {
        "all_interests": {
          "terms": {
            "field": "interests"
          }
        }
      }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Aggregations(a =>
                        a.Terms("all_interests", t =>
                            t.Field(f => f.Interests)))
            );
        Result = result.Aggregations;
    }

    11. Analytics limit

    If we want to know the popular interests of people called Smith, we can just add the appropriate query into the mix:

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
      "aggs": {
        "all_interests": {
          "terms": {
            "field": "interests"
          }
        }
      },
      "query": {
        "match": {
          "lastName": {
            "query": "smith"
          }
        }
      }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Query(q =>
                        q.Match(m =>
                            m.Field(fi =>
                                fi.LastName).Query("smith")))
                    .Aggregations(a =>
                        a.Terms("all_interests", t =>
                            t.Field(f => f.Interests)))
            );
        Result = result.Aggregations;
    }

    12. Analytics with Average

    POST http://localhost:9200/megacorp/employee/_search?pretty=true
    {
      "aggs": {
        "all_interests": {
          "terms": {
            "field": "interests"
          },
          "aggs": {
            "avg_age": {
              "avg": {
                "field": "age"
              }
            }
          }
        }
      }
    }
    public async Task ExecuteAsync()
    {
        var result = await client.SearchAsync<Employee>(
            s =>
                s.Type(typeEmployee)
                    .Aggregations(a =>
                        a.Terms("all_interests", t =>
                            t.Field(f =>
                                f.Interests)
                            .Aggregations(ag =>
                                ag.Average("avg_age", av =>
                                    av.Field(fi => fi.Age)))
                        )
                    )
     
            );
        Result = result.Aggregations;
    }

    13. Retrieving Part of a Document

    GET http://localhost:9200/website/blog/123?pretty=true&fields=title%2Ctext
    public async Task ExecuteAsync()
    {
        var response =
            await client.GetAsync(new DocumentPath<Blog>(123), g =>
                        g.Fields(f => f.Title, f => f.Text));
        Result = response.Fields;
    }

    14. Updating a Whole Document

    PUT http://localhost:9200/website/blog/123?pretty=true
    {
      "date": "2014-01-01T00:00:00",
      "id": 123,
      "text": "I am staring to get the hang of this...",
      "title": "My first blog entry"
    }
    public async Task ExecuteAsync()
    {
        var blog = new Blog()
        {
            Id = 123,
            Title = "My first blog entry",
            Text = "I am staring to get the hang of this...",
            Date = new DateTime(2014, 1, 1)
        };
        Result = await client.UpdateAsync(new DocumentPath<Blog>(123), u => u.Doc(blog));
    }

    15. Partial Updates to Documents

    POST http://localhost:9200/website/blog/1/_update?pretty=true
    {
      "doc": {
        "tags": [
          "testing"
        ],
        "views": 0
      }
    }
    public async Task ExecuteAsync()
    {
        var blog = new Blog()
        {
            Id = 1,
            Title = "My first blog entry",
            Text = "Just trying this out..."
        };
        await client.IndexAsync(blog);
     
        dynamic dyn = new ExpandoObject();
        dyn.Tags = new List<string>() { "testing" };
        dyn.Views = 0;
     
        Result = await client.UpdateAsync<Blog, dynamic>(new DocumentPath<Blog>(1), u =>
             u.Doc(dyn));
    }

    16. Deleting a Document

    DELETE http://localhost:9200/website/blog/123?pretty=true
    public async Task ExecuteAsync()
    {
        Result = await client.DeleteAsync(new DocumentPath<Blog>(123));
    }

    17. Cluster Health

    GET http://localhost:9200/_cluster/health?pretty=true
    public async Task ExecuteAsync()
    {
        Result = await client.ClusterHealthAsync();
    }

    18. Add an Index

    PUT http://localhost:9200/blogs?pretty=true
    {
      "settings": {
        "index.number_of_replicas": 1,
        "index.number_of_shards": 3
      }
    }
    public async Task ExecuteAsync()
    {
        Result = await client.CreateIndexAsync("blogs", c =>
                     c.Settings(s =>
                         s.NumberOfShards(3)
                         .NumberOfReplicas(1)));
    }

    19. Retrieving Part of a Document

    GET http://localhost:9200/website/blog/123?pretty=true&_source_include=title%2Ctext
    public async Task ExecuteAsync()
    {
        Result =
            await client.GetAsync<Blog>(new DocumentPath<Blog>(123), g =>
                 g.SourceInclude("title", "text"));
    }

    20. Using Versions from an External System

    PUT http://localhost:9200/website/blog/2?pretty=true&version=25&version_type=external
    {
      "date": "0001-01-01T00:00:00",
      "id": 0,
      "text": "Starting to get the hang of this...",
      "title": "My first external blog entry",
      "views": 0
    }
    public async Task ExecuteAsync()
    {
        var getResponse = (await client.GetAsync<Blog>(new DocumentPath<Blog>(2)));
        var blog = getResponse.Source;
        long version;
        if (blog == null)
        {
            blog = new Blog()
            {
                Title = "My first external blog entry",
                Text = "Starting to get the hang of this..."
            };
            var result = await client.IndexAsync(blog, i => i.Id(2));
            version = result.Version;
        }
        else
            version = getResponse.Version;
     
        Result = await client.IndexAsync(blog, i => i.Id(2).Version(version + 5).VersionType(VersionType.External));
    }

    21. Using Scripts to Make Partial Updates

    POST http://localhost:9200/website/blog/1/_update?pretty=true
    {
      "script": "ctx._source.views += 1"
    }
    public async Task ExecuteAsync()
    {
        Result = await client.UpdateAsync(new DocumentPath<Blog>(1), u =>
            u.Script("ctx._source.views += 1"));
    }
    POST http://localhost:9200/website/blog/1/_update?pretty=true
    {
      "script": "ctx._source.tags+=new_tag",
      "params": {
        "new_tag": "search"
      }
    }
    public async Task ExecuteAsync()
    {
        Result = await client.UpdateAsync(new DocumentPath<Blog>(1), u =>
            u.Script("ctx._source.tags+=new_tag")
            .Params(p => p.Add("new_tag", "search")));
    }
    POST http://localhost:9200/website/blog/1/_update?pretty=true
    {
      "script": "ctx.op = ctx._source.views == count ? 'delete' : 'none'",
      "params": {
        "count": "1"
      }
    }
    Result = await client.UpdateAsync(new DocumentPath<Blog>(1), u =>
                    u.Script("ctx.op = ctx._source.views == count ? 'delete' : 'none'")
                    .Params(p => p.Add("count", "1")));

    22. Updating a Document That May Not Yet Exist

    Imagine that we need to store a page view counter in Elasticsearch. Every time that a user views a page, we increment the counter for that page. But if it is a new page, we can’t be sure that the counter already exists. If we try to update a nonexistent document, the update will fail.
    In cases like these, we can use the upsert parameter to specify the document that should be created if it doesn’t already exist

    POST http://localhost:9200/website/pageviews/1/_update?pretty=true
    {
      "script": "ctx._source.views+=1",
      "upsert": {
        "id": 0,
        "views": 1
      }
    }
    public async Task ExecuteAsync()
    {
        Result = await client.UpdateAsync(new DocumentPath<PageViews>(1), u =>
            u.Script("ctx._source.views+=1")
            .Upsert(new PageViews() { Views = 1 }));
    }

    23. Updates and Conflicts

    POST http://localhost:9200/website/pageviews/1/_update?pretty=true&retry_on_conflict=5
    {
      "script": "ctx._source.views+=1",
      "upsert": {
        "id": 1,
        "views": 0
      }
    }
    Result = await client.UpdateAsync(new DocumentPath<PageViews>(1), u =>
                    u.Script("ctx._source.views+=1")
                        .Upsert(new PageViews { Id = 1, Views = 0 })
                        .RetryOnConflict(5));

    24. Retrieving Multiple Documents

    POST http://localhost:9200/_mget?pretty=true
    {
      "docs": [
        {
          "_index": "website",
          "_type": "blog",
          "_id": 2
        },
        {
          "_index": "website",
          "_type": "pageviews",
          "_id": 1
        }
      ]
    }
    public async Task ExecuteAsync()
    {
        Result = await client.MultiGetAsync(m =>
            m.Get<Blog>(g =>
                g.Id(2))
            .Get<PageViews>(ge =>
                ge.Id(1))
            );
    }
    POST http://localhost:9200/website/blog/_mget?pretty=true
    {
      "ids": [
        2,
        1
      ]
    }
     
     
     
    Result = await client.MultiGetAsync(m =>
        m.Index(indexWebsite)
        .Type(typeBlog)
        .GetMany<Blog>(new long[] { 2, 1 }));

    100. Source code

    Source code: https://bitbucket.org/hintdesk/dotnet-elasticsearch-nest-examples-for-mapping-between-query

  • 相关阅读:
    aws s3文件上传设置accesskey、secretkey、sessiontoken
    HTTP的Referrer和Referrer Policy设置
    小技巧-mac修改finder菜单栏
    使用katalon自带Spy功能获取/验证控件Selector、XPath
    java的8种基础类型
    Mac-搭建Hadoop集群
    新公司入职56天后的面谈小结
    Java对字符串加密并返回星号※
    为什么要写设计文档
    在Linux上部署Web项目
  • 原文地址:https://www.cnblogs.com/a-du/p/7095844.html
Copyright © 2011-2022 走看看