tutorial - ElasticSearch-NEST-cómo combinar instrucciones AND y OR

update by query document elasticsearch

Question

Soy nuevo en ElasticSearch - NEST API.

Estamos tratando de preparar múltiples condiciones con cláusulas Y / O. Por ejemplo - (Condición 1 O Condición 2) Y (Condición 3)

Actualmente estamos tratando de concatenar las condiciones de consulta.

¿Alguien puede dar el mejor ejemplo usando NEST API?

Answer 1

Aquí está la configuración y consulta de datos brutos:

PUT hilden1
POST hilden1/type1
{
"f1": 123,
"f2": 456,
"f3": 789
}
GET hilden1/type1/_search
{
"query": {
"filtered": {
"filter": {
"and": {
"filters": [
{
"term": {
"f1": "123"
}
},
{
"or": {
"filters": [
{
"term": {
"f2": "456"
}
},
{
"term": {
"f3": "888"
}
}
]
}
}
]
}
}
}
}
}

Aquí está el equivalente del nido aproximado:

 var search = ElasticClient.Search<AuthForReporting>(s=> s
.Query(q=> q
.Filtered(fq => fq
.Filter(f=> f
.And(
a=> a.Term(t=> t.f1, 123),
a => a.Or(
o => o.Term(t=>t.f2, 456),
o => o.Term(t => t.f3, 888)
)
)
)
)
)
);

Answer 2

Bueno, hay algo llamado Bool Query en ElasticSearch. Una consulta que coincide con los documentos que coinciden con combinaciones booleanas (Y, O, NO) de otras consultas. Está construido usando una o más cláusulas booleanas, cada cláusula con una ocurrencia tipada. Los tipos de ocurrencia son:

debe: (Y) La cláusula (consulta) debe aparecer en documentos coincidentes.

debería: (O) La cláusula (consulta) debería aparecer en el documento correspondiente. En una consulta booleana sin cláusulas must, una o más cláusulas must deben coincidir con un documento. El número mínimo de cláusulas should para coincidir se puede establecer utilizando el parámetro minimum_should_match.

must_not: (NOT) La cláusula (consulta) no debe aparecer en los documentos coincidentes.

Entonces, para el ejemplo que ha dado, obtendrá la siguiente consulta:

bool
should
condition 1
condition 2
bool
must
condition 3

Y en ElasticSearch el código se verá así:

"filter": {
"bool": {
"should": [
{"term": {"tag": value1}},
{"term": {"tag": value2}}
],
"bool": {
"must":{"term": {"tag": "value3"}}
}
}
}

Y en NEST se verá así:

Filter(f=>f
.Bool(b=>b
.Should(
o=>o.Term(t=>t.Tag, Value1),
o=>o.Term(t=>t.Tag, Value2)),
o=>o.Bool(bo=>bo
.Must(a=>a.Term(t=>t.Tag, Value3))
)
)
)

Según la documentación de NEST, en lugar de escribir consultas tan prolijas y prolijas, puedes usar los operadores Bitwise de NEST, que es simple.

.Query((q=>q.Term(tag, value1) || q.Term(tag, value2)) && q.Term(tag, value3))