Tabla de contenido
La diferencia entre matchQuery, matchPhraseQuery y termQuery en RestHighLevelClient en uso real
¿Puede ES usar palabras clave dentro de campos de tipo texto?Si es así, ¿qué significa?
¿Cómo implementa ES la consulta de agregación?
¿Qué es la subagregación de RestHighLevelClient?¿Para qué sirve?
¿Qué es la consulta de desplazamiento de RestHighLevelClient? ¿Como alcanzar?
¿Qué es BoolQueryBuilder?
BoolQueryBuilder es un generador de consultas en la biblioteca del cliente para crear consultas booleanas. Una consulta booleana es una consulta compuesta que combina varias condiciones de consulta.
BoolQueryBuilder proporciona varios métodos para crear consultas booleanas:
1. must(QueryBuilders): agregue una condición de consulta "debe coincidir" (must). Esto significa que los documentos deben cumplir con los criterios de consulta para poder ser devueltos. Equivalente a y en sql
2. mustNot(QueryBuilders): Agregue una condición de consulta "no debe". Esto significa que el documento no debe cumplir con los criterios de consulta para ser devuelto. Equivalente a no es
3. should(QueryBuilders): agregue una condición de consulta "debería coincidir". Esto significa que los documentos pueden satisfacer los criterios de consulta, pero no necesariamente. equivalente a o
4. filter(QueryBuilders): agregue un "filtro" (filtro) de condiciones de consulta. Similar a la condición de consulta obligatoria, pero la consulta de filtro no calcula la puntuación de relevancia, que generalmente se usa para filtrar los resultados. Equivalente a seleccionar campo
consulta compuesta simple
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
.must(QueryBuilders.termQuery("field1", "value1"))
.mustNot(QueryBuilders.termQuery("field2", "value2"))
.should(QueryBuilders.termQuery("field3", "value3"))
.filter(QueryBuilders.termQuery("field4", "value4"));
// 将boolQuery用于搜索请求
SearchRequest searchRequest = new SearchRequest("indexName");
searchRequest.source(new SearchSourceBuilder().query(boolQuery));La diferencia entre matchQuery, matchPhraseQuery y termQuery en RestHighLevelClient en uso real
1. matchQuery:
MatchQuery es una consulta de texto completo que analiza el texto proporcionado y genera una consulta que realiza una búsqueda de texto completo en el texto analizado. Es útil cuando desea realizar una búsqueda basada en la relevancia. MatchQuery analiza el texto y genera un conjunto de términos que se utilizan para la coincidencia.traducir:
1. Consulta de coincidencia:
matchQuery es una consulta de texto completo que analiza el texto proporcionado y genera una consulta que realiza una búsqueda de texto completo en el texto analizado. Es útil cuando desea realizar búsquedas basadas en la relevancia. matchQuery analiza el texto y genera un conjunto de términos para hacer coincidir.2. matchPhraseQuery:
MatchPhraseQuery es similar a matchQuery, pero analiza el texto como una frase en lugar de términos individuales. Es útil cuando desea buscar una frase exacta en el texto. MatchPhraseQuery considera el orden de los términos y su proximidad entre sí.2. Consulta de coincidencia de frases:
matchPhraseQuery es similar a matchQuery, pero analiza el texto como frases en lugar de términos individuales. Es útil cuando desea buscar una frase exacta en el texto. matchPhraseQuery tiene en cuenta el orden de los términos y su proximidad entre sí.termQuery: termQuery es una consulta que busca términos exactos en un campo. No analiza el texto y es adecuado para buscar en campos de palabras clave o campos que no se analizan. termQuery coincide con documentos que contienen un término exacto.
Consulta de términos:
termQuery es una consulta que busca un término exacto en un campo. No analiza texto y es adecuado para buscar campos de palabras clave o campos no analizados. termQuery encuentra documentos que contienen el término exacto.Resumir:
matchQuery y matchPhraseQuery se usan para la búsqueda de texto completo y consideran la relevancia, mientras que termQuery se usa para la coincidencia exacta de términos y no realiza análisis en el texto. Puede elegir el tipo de consulta adecuado en función de sus requisitos de búsqueda específicos.
OK,
Entonces, en términos simples,
Si busca aleatoriamente, use matchQuery para completar la coincidencia aproximada,
Busque palabras clave vagas usando matchPhraseQuery
Realice una búsqueda precisa de segmentación de palabras en el campo especificado, que es adecuado para la búsqueda precisa de palabras clave.
¿Puede ES usar palabras clave dentro de campos de tipo texto?Si es así, ¿qué significa?
En Elasticsearch, puede usar "palabra clave" dentro de un campo de tipo "texto".
Este uso se denomina "campos múltiples" y le permite definir múltiples subcampos de diferentes tipos en el mismo campo.
Cuando define un subcampo de "palabra clave" en un campo de tipo "texto", sus significados son:
1. Subcampo de tipo "texto": este subcampo analizará el texto y lo dividirá en términos individuales, y aplicará componentes del analizador como tokenizadores y filtros Esto permite la búsqueda de texto completo y la puntuación por relevancia.
2. Subcampo de tipo "palabra clave": este subcampo indexará y buscará todo el texto como un elemento sin segmentación ni análisis de palabras. Esto permite operaciones de coincidencia, clasificación y agregación exactas.
La ventaja de este uso es que puede admitir operaciones de búsqueda de texto completo y de coincidencia exacta en el mismo campo sin tener que definir campos adicionales. Por ejemplo, puede utilizar un subcampo de tipo "texto" para la búsqueda de texto completo y un subcampo de tipo "palabra clave" para la coincidencia u ordenación exactas.
Aquí hay un ejemplo que muestra cómo definir un campo con los subcampos "texto" y "palabra clave" en Elasticsearch:
json
{ "mappings": { "properties": { " title": { "type": "text", "fields" :
} }
}
En
el ejemplo anterior, el campo "título" se define como de tipo "texto" y contiene un subcampo de tipo "palabra clave" denominado "palabra clave". De esta forma, puede realizar una búsqueda de texto completo y una operación de coincidencia exacta en el campo "título" al mismo tiempo.
Para resumir, puede usar un subcampo de "palabra clave" dentro de un campo de tipo "texto" para admitir tanto la búsqueda de texto completo como la coincidencia exacta.combate real:
campo
"agent_name": { "type": "text", "fields": { "keyword": { "ignore_above": 256, "type": "keyword" } } },Se requiere que coincida con precisión toda la información de que agent_name es Henan Shenlong Company.
// 指定索引 request.indices("smsp_collect_info_new"); // 构建查询条件 SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder(); // 使用精准分词 查找 searchSourceBuilder.query(QueryBuilders.termQuery("agent_name.keyword", "河南神龙公司")); //放入文档中 request.source(searchSourceBuilder); //远程查询 SearchResponse response = client.search(request, RequestOptions.DEFAULT); //获取结果 SearchHit[] searchHits = response.getHits().getHits(); for (SearchHit hit : searchHits) { System.out.println(hit.getSourceAsMap().get("agent_name")); }El campo agent_name aquí usa la idea/método de campos múltiples.
¿Qué es ES multicampo?
ES Multi-fields (Multi-campos) es un concepto en Elasticsearch que permite definir múltiples subcampos de diferentes tipos en un campo. Cada subcampo se puede procesar e indexar de manera diferente según las diferentes necesidades, para proporcionar funciones más flexibles al buscar y agregar.
El propósito principal de usar múltiples campos es admitir múltiples requisitos de consulta en el mismo campo al mismo tiempo. Por ejemplo, es posible que desee realizar operaciones como búsqueda de texto completo, coincidencia exacta y clasificación en un campo. Mediante el uso de varios campos, puede definir diferentes tipos de subcampos de acuerdo con los diferentes requisitos de consulta, a fin de utilizar los métodos de consulta adecuados en cada subcampo.
Se pueden definir varios campos en las asignaciones. Aquí hay un ejemplo que muestra cómo definir un campo de varios campos en Elasticsearch:
json
{ "mappings": { "properties": { "title": { "type": "text", "fields": { "keyword": { "tipo": "palabra clave" }, "inglés": { "tipo": "texto",
}
}
En el ejemplo anterior, el campo "título" se define como tipo "texto" y contiene dos subcampos: "palabra clave" e "inglés". Entre ellos, el subcampo "palabra clave" es del tipo "palabra clave" para la coincidencia y clasificación exactas, mientras que el subcampo "inglés" es del tipo "texto" y utiliza el analizador de inglés para la búsqueda de texto completo.
Mediante el uso de varios campos, puede seleccionar los subcampos apropiados para buscar, clasificar y agregar de acuerdo con los diferentes requisitos de consulta, proporcionando así una experiencia de búsqueda más flexible y precisa.
En general, ES multicampo es para definir múltiples subcampos de diferentes tipos en un campo para proporcionar funciones flexibles de búsqueda y agregación bajo diferentes requisitos de consulta.
¿Cómo implementa ES la consulta de agregación?
Se realiza principalmente construyendo condiciones de agregación a través de AggregationBuilders y luego empalmando AggregationBuilders en SearchSourceBuilder a través del método de agregación. Si hay una subagregación, se ensambla a través del método de subagregación.
Tipos de consultas de agregación
- Agregación de rango: campos agregados de acuerdo con un rango específico, como la agregación de productos básicos por rango de precios.
- Agregación de histograma de fecha: agrega campos de fecha en intervalos de tiempo específicos, como la agregación de datos de ventas por mes.
- Agregación de histogramas: agrega campos numéricos a intervalos específicos, como la agregación de productos básicos por rango de precios.
- Agregación de términos: Agrega términos para campos, similar a la operación GROUP BY en SQL.
- Agregación promedio: calcula el valor promedio del campo.
- Sum Aggregation: Calcula la suma de campos.
- Agregación máxima: Calcula el valor máximo de un campo.
- Min Aggregation: Calcula el valor mínimo del campo.
- Agregación de Cardinalidad: Calcula la cardinalidad (número de valores distintos) de un campo.
Consulta + Agregación de grupo Combate real
public void GroupSearch() throws IOException { SearchRequest request = new SearchRequest(); SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); request.indices("smsp_collect_info_new"); // 模糊分词查询 searchSourceBuilder.query(QueryBuilders.matchQuery("province", "河南")); // 分组聚合查询 searchSourceBuilder.aggregation(AggregationBuilders .terms("your_agg_name") .field("agent_name.keyword") .subAggregation(AggregationBuilders.count("count_number") // 指定返回的桶的最大数量为10000 .field("company.keyword")).size(10000)); //放入文档中 request.source(searchSourceBuilder); //远程查询 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 获取所有的桶 Terms termsAggregation = response.getAggregations().get("your_agg_name"); for (Terms.Bucket bucket : termsAggregation.getBuckets()) { // 获得每次聚合的key的值 System.out.println("当前的key为："+bucket.getKeyAsString()); ValueCount countAggregation =bucket.getAggregations().get("count_number"); System.out.println("当前键下的聚合属性的总和，"+countAggregation.getValue()); } }
¿Qué es la subagregación de RestHighLevelClient?¿Para qué sirve?
La subAgregación de RestHighLevelClient es una función para operaciones de agregación anidadas en Elasticsearch. En Elasticsearch, la agregación es una función para agrupar, filtrar y calcular datos Puede realizar estadísticas, calcular promedios y sumas en campos de acuerdo con diferentes tipos de agregación.
La subagregación permite realizar más operaciones de agregación anidadas en el resultado de una operación de agregación.
Mediante el uso de subAggregation, se pueden realizar análisis y procesamientos más detallados de los resultados de agregación.
Por ejemplo, se pueden realizar subagregaciones sobre los resultados de la agregación de términos, con estadísticas más profundas para cada cubo de agregación.
El siguiente es un código de muestra para la subagregación mediante RestHighLevelClient:
RestHighLevelClient client = new RestHighLevelClient( RestClient.builder(new HttpHost("localhost", 9200, "http"))); SearchRequest searchRequest = new SearchRequest("your_index_name"); // 替换为实际的索引名 SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); // 添加主聚合 TermsAggregationBuilder aggregationBuilder = AggregationBuilders.terms("my_terms_agg") .field("your_field_name"); // 替换为实际的字段名 // 添加子聚合 MaxAggregationBuilder subAggregationBuilder = AggregationBuilders.max("my_max_agg") .field("your_nested_field_name"); // 替换为实际的嵌套字段名 aggregationBuilder.subAggregation(subAggregationBuilder); searchSourceBuilder.aggregation(aggregationBuilder); searchRequest.source(searchSourceBuilder); try { SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT); // 解析聚合结果 Terms termsAggregation = searchResponse.getAggregations().get("my_terms_agg"); for (Terms.Bucket bucket : termsAggregation.getBuckets()) { String key = bucket.getKeyAsString(); Max maxAggregation = bucket.getAggregations().get("my_max_agg"); double max = maxAggregation.getValue(); // 处理聚合结果 System.out.println("Bucket Key: " + key); System.out.println("Max Value: " + max); } } catch (IOException e) { e.printStackTrace(); } client.close();
¿Qué es la consulta de desplazamiento de RestHighLevelClient? ¿Como alcanzar?
La consulta continua de RestHighLevelClient es un mecanismo para recuperar grandes cantidades de datos en Elasticsearch. Le permite obtener conjuntos de resultados de forma iterativa en varias solicitudes en lugar de obtener todos los resultados a la vez. Las consultas continuas son adecuadas para situaciones en las que es necesario procesar una gran cantidad de datos, como la exportación de datos, el análisis de datos, etc.
En comparación con otros métodos de consulta, la consulta de desplazamiento tiene las siguientes ventajas:
1. Puede manejar una gran cantidad de datos: la consulta de desplazamiento es adecuada para tratar situaciones que exceden el límite del tamaño del conjunto de resultados de una sola solicitud. Le permite obtener datos a pedido sin fallas en la solicitud o degradación del rendimiento debido a un volumen de datos excesivo.
2. Ahorre memoria: las consultas de desplazamiento reducen el consumo de memoria al devolver un pequeño lote de resultados cada vez y mantener el contexto de desplazamiento en el lado del servidor. Esto hace que no sea necesario cargar todos los resultados en la memoria cuando se procesan grandes cantidades de datos, ahorrando así recursos de memoria.
3. Admite consulta continua: el resultado de la consulta continua se puede utilizar de forma continua, incluso si los datos en el índice cambian durante el procesamiento. Puede usar contextos de desplazamiento para mantener la coherencia de las consultas independientemente de las actualizaciones del índice.
4. Admite el procesamiento simultáneo: al utilizar la consulta de desplazamiento, puede procesar varios contextos de desplazamiento al mismo tiempo, lo que mejora el rendimiento y la eficiencia de la consulta.
Cabe señalar que la consulta de desplazamiento también tiene algunas limitaciones y precauciones:
1. La consulta de desplazamiento ocupará recursos del servidor: dado que el contexto de desplazamiento debe mantenerse en el lado del servidor, ocupará una cierta cantidad de memoria y recursos informáticos. Al diseñar una consulta continua, debe tener en cuenta los recursos disponibles del servidor y el rendimiento de simultaneidad de la consulta.
2. Es posible que el resultado de la consulta continua no sea en tiempo real: si los datos del índice cambian durante la consulta continua, es posible que el resultado de la consulta continua no refleje los datos más recientes. Por lo tanto, al procesar datos en una consulta continua, se debe prestar atención a la coherencia y el rendimiento en tiempo real de los datos.
En resumen, la consulta continua de RestHighLevelClient es un mecanismo poderoso para procesar de manera eficiente grandes cantidades de datos. Proporciona una forma flexible de obtener resultados por lotes y es adecuado para escenarios que necesitan procesar grandes cantidades de datos.lograr:
public void ScrollSearch() throws IOException { SearchRequest request = new SearchRequest(); //失效时间为10min Scroll scroll = new Scroll(TimeValue.timeValueMinutes(10)); //封存快照 request.scroll(scroll); SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); request.indices("smsp_collect_info_new"); searchSourceBuilder.query(QueryBuilders.matchQuery("province", "黑龙江")); // 每次查询2000个，是滚动查询条数的步长 searchSourceBuilder.size(2000); //放入文档中 request.source(searchSourceBuilder); //远程查询 SearchResponse response = client.search(request, RequestOptions.DEFAULT); SearchHit[] searchHits = response.getHits().getHits(); //处理第一次的响应结果 for (SearchHit hit : searchHits) { String province = hit.getSourceAsMap().get("province").toString(); System.out.println(province); // 处理每个查询结果 } // 获取第一次的滚动id String scrollId = response.getScrollId(); while (searchHits.length > 0) { // 每循环一次构建一个新的滚动请求。 SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId); scrollRequest.scroll(TimeValue.timeValueMinutes(1)); response = client.scroll(scrollRequest, RequestOptions.DEFAULT); // 获取新的滚动请求的滚动id scrollId = response.getScrollId(); searchHits = response.getHits().getHits(); // 处理下一批查询结果 for (SearchHit hit : searchHits) { String province = hit.getSourceAsMap().get("province").toString(); System.out.println(province); // 处理每个查询结果 } } }
ES crea una búsqueda simple
usar coincidencia aproximada
public void simpleSearch() throws IOException {
SearchRequest request = new SearchRequest();
// 指定索引
request.indices("smsp_collect_info_new");
// 构建查询条件 查询某城市
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchQuery("city", "郑州"));
//放入文档中
request.source(searchSourceBuilder);
//远程查询
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//获取结果
SearchHit[] searchHits = response.getHits().getHits();
for (SearchHit hit : searchHits) {
System.out.println(hit.getSourceAsMap().get("city"));
}
}usar coincidencia exacta
// 单条件精准查询
public void simpleSearchUseTerm() throws IOException {
SearchRequest request = new SearchRequest();
// 指定索引
request.indices("smsp_collect_info_new");
// 构建查询条件 查询某城市
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// 使用精准分词 查找
searchSourceBuilder.query(QueryBuilders.termQuery("agent_name.keyword", "河南神龙公司"));
//放入文档中
request.source(searchSourceBuilder);
//远程查询
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//获取结果
SearchHit[] searchHits = response.getHits().getHits();
for (SearchHit hit : searchHits) {
System.out.println(hit.getSourceAsMap().get("agent_name"));
}
}
