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
My strongly recommended books to read. Choose one and enjoy yourself.
