篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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
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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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
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:
{
"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:
{
"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
public async Task ExecuteAsync()
{
Result = await client.DeleteAsync(new DocumentPath<Blog>(123));
}
|
17. Cluster Health
public async Task ExecuteAsync()
{
Result = await client.ClusterHealthAsync();
}
|
18. Add an Index
PUT http:
{
"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
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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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:
{
"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
以上是关于Elasticsearch NEST – Examples for mapping between Query and C#的主要内容，如果未能解决你的问题，请参考以下文章