Elasticsearch-基本命令

清疚 2023-10-18 18:41 18阅读 0赞

#### 基本命令 ####

*   *  创建索引
     *  添加数据
     *  删除数据
     *  简单查询
     *  复杂查询1
     *  复杂查询2
     *  获得所有index
     *  获得所有mapping-type
     *  根据某个字段精确查找
     *  api的分组查询
     *  bool查询

### 创建索引 ###

put http://localhost:9200/index01
    {
    	"mappings": {
    		"type1": {
    			"properties": {
    				"field1": {
    					"type": "string",
    					"analyzer": "ik_max_word"
    				},
    				"field2": {
    					  "type": "string"
    				}
    			}
    		}
    	}
    }

### 添加数据 ###

post http://localhost:9200/index01/_bulk?pretty
    1.{"index":{"_index":"index01", "_type":"type1", "_id":"2"} }
    2.{"field1":"程序设计也是设计，研发新菜也是研发","field2":"五道口"}
    3.(_bulk格式：最后一行需空出)

### 删除数据 ###

Client client = elasticsearchTemplate.getClient();
                DeleteResponse response = client.prepareDelete().setIndex("dmac").setType("md").setId(params.get("instanceId").toString())
                        .setRefresh(true).execute().actionGet();

### 简单查询 ###

post http://localhost:9200/index01/_search
    {"query":{
            "match":{
                "field1":"程序"
            }
        }
    }

### 复杂查询1 ###

{
      "query": {
        "bool": {
          "must": [
            {"term": {"a": "1"}},
            {"term":{"b": "2"}}
            {
              "bool": {
                "should": [
                    {"term": {"c": "1"}},
                　　{"term": {"d": "2"}}
                ]
              }
            }
          ]
        }
      },
      "sort": {
        "time": {
          "order": "desc"
        }
      },
      "size": 100
    }

### 复杂查询2 ###

{
      "query": {
        "bool": {
          "should": [
            {
              "bool": {
                "must": [
                    {"term": {"a": "1"}},
                    {"term":{"b": "2"}},
                    {"term": {"c": "1"}}
                ]
              }
            },
            {
              "bool": {
                "must": [
                    {"term": {"a": "1"}},
                    {"term":{"b": "2"}},
                　　{"term": {"d": "2"}}
                ]
              }
            }
          ]
        }
      },
      "sort": {
        "time": {
          "order": "desc"
        }
      },
      "size": 100
    }

### 获得所有index ###

- rest方式：
    	curl 'localhost:9200/_cat/indices?v'
    	
     - JAVA方式
    		GetIndexResponse response = client.admin().indices().prepareGetIndex().execute().actionGet(); 					 System.out.println(response.getIndices().length);
    	 String[] indices = response.getIndices();
    	  for(String indice : indices){ 
    	  System.out.println(indice); 
    	  }

### 获得所有mapping-type ###

- rest方式：
     	curl -XGET 'http://localhost:9200/_mapping?pretty=true'
     - 非格式化：
     	curl -s -XGET 'http://localhost:9200/_mapping'
     	
     - JAVA方式：
     	GetMappingsResponse res = null; 
    	try { 
    		res = client.admin().indices().getMappings(new GetMappingsRequest().indices(indice)).get();
    	 } catch (InterruptedException e) { 
    		 e.printStackTrace(); 
    	 } catch (ExecutionException e) {
    	 	 e.printStackTrace(); 
    	 }
    	 ImmutableOpenMap<String, MappingMetaData> mapping = res.mappings().get(indice); 
    	 for (ObjectObjectCursor<String, MappingMetaData> c : mapping) 
    	 { 
    	 	 System.out.println("type = "+c.key); 
    	 	 System.out.println("columns = "+c.value.source());
    	  }

### 根据某个字段精确查找 ###

- rest方式：
     	curl -XGET 'http://127.0.0.1:9200/index/type/_search?pretty&q=name:Tom'

*  api的bool查询

public Page<?> listInstance(Map<String, Object> params) {
            int pageCurrent = params.get("pageCurrent") == null ? 1 : (Integer) params.get("pageCurrent");
            int pageSize = params.get("pageSize") == null ? 10 : (Integer) params.get("pageSize");
            Pageable pageable = new PageRequest(pageCurrent - 1, pageSize);
            //获取属于用户的系统视图的元数据id
            List<String> sysViewsInstanceId = new ArrayList<>();
            if(params.get("instanceIds")!=null){
                String[] viewIds = params.get("instanceIds").toString().split(",");
                sysViewsInstanceId = java.util.Arrays.asList(viewIds);
            }else{
                sysViewsInstanceId = this.getSysViewInstanceId(params);
            }
            //构件查询条件
            BoolQueryBuilder builder = QueryBuilders.boolQuery();
            BoolQueryBuilder subQuery = QueryBuilders.boolQuery();
            for (String viewsInstanceId : sysViewsInstanceId) {
                subQuery.should(QueryBuilders.queryStringQuery(viewsInstanceId).queryName("namespace"));
            }
            builder.must(subQuery);
            if(params.get("classifierId")!=null){
                BoolQueryBuilder subQuery2 = QueryBuilders.boolQuery();
                subQuery2.must(QueryBuilders.queryStringQuery(params.get("classifierId").toString()).queryName("classifierId"));
                builder.must(subQuery2);
            }
            if(params.get("searchValue")!=null){
                BoolQueryBuilder subQuery3 = QueryBuilders.boolQuery();
                subQuery3.should(QueryBuilders.wildcardQuery("code", "*" + params.get("searchValue").toString().toUpperCase() + "*"));
                subQuery3.should(QueryBuilders.wildcardQuery("name", "*" + params.get("searchValue").toString().toUpperCase() + "*"));
                builder.must(subQuery3);
            }
    
            //构建排序条件
            FieldSortBuilder codeSortBuilder = SortBuilders.fieldSort("code").order(SortOrder.ASC);
            FieldSortBuilder idSortBuilder = SortBuilders.fieldSort("id").order(SortOrder.ASC);
            // 分页、查询、排序
            SearchQuery searchQuery = new NativeSearchQueryBuilder()
                    .withPageable(pageable)
                    .withQuery(builder)
                    .withSort(codeSortBuilder)
                    .withSort(idSortBuilder)
                    .build();
            org.springframework.data.domain.Page<MetadataModel> search = metadataRepository.search(searchQuery);
    
            List<MetadataModel> content = search.getContent();
            Page<MetadataModel> page = new Page<>();
            page.setTotal(search.getTotalElements());
            page.addAll(content);
            int total = (int) page.getTotal();
            List<Map<String, Object>> data2 = new ArrayList<>(total);
            Map<String, Object> temp;
            for (int i = 0; i < page.getResult().size(); i++) {
                MetadataModel metadata = page.getResult().get(i);
                temp = new HashMap<>();
                temp.put("CLASSIFIER_ID", metadata.getClassifierId());
                temp.put("CLASSIFIER_NAME", metadata.getClassifierName());
                temp.put("INSTANCE_CODE", metadata.getCode());
                temp.put("INSTANCE_ID", metadata.getId());
                temp.put("INSTANCE_NAME", metadata.getName());
                temp.put("NAMESPACE", metadata.getPath());
                data2.add(temp);
            }
            Page<Map<String, Object>> page2 = new Page<>();
            page2.setTotal(total);
            page2.addAll(data2);
            return page2;
        }
        
    其中逻辑的DSL表达式如下：
    {
        "query":{
            "bool":{
                "must":[
                    {
                        "bool":{
                            "should":[
                                {
                                    "query_string":{
                                        "query":"3223076994024b718f70ef507705ff03",
                                        "_name":"namespace"
                                    }
                                },
                                {
                                    "query_string":{
                                        "query":"3223076994024b718f70ef507705ff03",
                                        "_name":"namespace"
                                    }
                                }
                            ]
                        }
                    },
                    {
                        "bool":{
                            "must":{
                                "query_string":{
                                    "query":"Table",
                                    "_name":"classifierId"
                                }
                            }
                        }
                    },
                    {
                        "bool":{
                            "should":[
                                {
                                    "wildcard":{
                                        "code":"*TB*"
                                    }
                                },
                                {
                                    "wildcard":{
                                        "name":"*TB*"
                                    }
                                }
                            ]
                        }
                    }
                ]
            }
        }
    }

### api的分组查询 ###

public Map<String, String> listInstanceType(Map<String, Object> params) {
            Client client = elasticsearchTemplate.getClient();
            //获取属于用户的系统视图的元数据id
            List<String> sysViewsInstanceId = new ArrayList<>();
            if(params.get("instanceIds")!=null){
                String[] viewIds = params.get("instanceIds").toString().split(",");
                sysViewsInstanceId = java.util.Arrays.asList(viewIds);
            }else{
                sysViewsInstanceId = this.getSysViewInstanceId(params);
            }
            BoolQueryBuilder builder = QueryBuilders.boolQuery();
            BoolQueryBuilder subQuery = QueryBuilders.boolQuery();
            for (String viewsInstanceId : sysViewsInstanceId) {
                subQuery.should(QueryBuilders.queryStringQuery(viewsInstanceId).queryName("namespace"));
            }
            builder.must(subQuery);
            FieldSortBuilder codeSortBuilder = SortBuilders.fieldSort("code").order(SortOrder.ASC);
            //子查询
            AggregationBuilder group= AggregationBuilders.terms("agg-class")
                    .field("classifierId");    //.order(Terms.Order.count(false)).size(0)
    
            SearchRequestBuilder searchRequestBuilder = client
                    .prepareSearch("dmac").setTypes("md")
                    .setQuery(builder)
                    .addAggregation(group)
                    ;
            SearchResponse searchResponse = searchRequestBuilder.execute()
                    .actionGet();
            Terms terms = searchResponse.getAggregations().get("agg-class");
            Collection<Terms.Bucket> buckets = terms.getBuckets();
            Map<String, String> dataMap = new HashMap<String, String>();
            for (Terms.Bucket bucket : buckets) {
                String key = bucket.getKey()+"";
                dataMap.put(key.toUpperCase(), bucket.getDocCount() + "");
            }
            return dataMap;
        }

### bool查询 ###

GET 51jobs/job/_search
    {
      "query": {
        "bool": {
          "must": {
            "match_all": {}
          }, 
          "filter": {
            "term": {
              "salary": 6666
            }
          
          }
        }
      }
    }
    
    # select * from job where salary=6666 or salary=7777
    # 查询所有数据，筛选出工资等于6666或者7777的数据
    GET 51jobs/job/_search
    {
      "query": {
        "bool": {
          "must": {
            "match_all": {}
          }, 
          "filter": {
            "terms": {
              "salary": [6666,7777]
            }
          
          }
        }
      }
    }
    # 查询salary等于6666或者title等于python、salary不等于7777、salary不等于8888
    
    GET 51jobs/job/_search
    {
      "query": {
        "bool": {
          "should": [
            {"term": {
              "salary": {
                "value": 6666
              }
            }},
            {"term": {
              "title": {
                "value": "python"
              }
            }}
          ],
          "must_not": [
            {"term": {
              "salary": {
                "value": 7777
              }
            }},
            {"term": {
              "salary": {
                "value": 8888
              }
            }}
          ]
        }
      }
    }
    
    # salary等于6666或者title等于python salary不等于9999 title不等于redis
    
    GET 51jobs/job/_search
    {
      "query": {
        "bool": {
          "should": [
            {"term": {
              "salary": {
                "value": 6666
              }
            }},
            {"term": {
              "title": {
                "value": "python"
              }
            }}
          ],
          "must_not": [
            {"term": {
              "salary": {
                "value": 9999
              }
            }},
            {
              "term": {
                "title": {
                  "value": "redis"
                }
              }
            }
          ]
        }
      }
    }
    # 查询title为python或者(title为搜索并且salary等于6666)的数据
    GET 51jobs/job/_search
    {
      "query": {
        "bool": {
          "should": [
            {"term": {
              "title": {
                "value": "python"
              }
            }},
            {
              "bool": {
                "must": [
                  {"term": {
                    "title": {
                      "value": "搜索"
                    }
                  }},
                  {
                    "term": {
                      "salary": {
                        "value": 6666
                      }
                    }
                  }
                ]
              }
              
            }
          ]
        }
      }
    }
    
    
    # 添加空值测试数据
    PUT nulldb/test/_bulk
    {"index":{"_id":1}}
    {"tags":["IT","python"]}
    {"index":{"_id":2}}
    {"tags":["java","python"]}
    {"index":{"_id":3}}
    {"tags":null}
    {"index":{"_id":4}}
    {"tags":["IT","php"]}
    {"index":{"_id":5}}
    {"tags":[null,"python"]}
    
    
    # 处理null空值
    # 过滤空值
    # exists 处理值不为空或者值不为null的数据
    GET nulldb/test/_search
    {
      "query": {
        "bool": {
          "filter": {
            "exists": {
              "field": "tags"
            }
          }
        }
      }
    }
    
    # 筛选出tags值为空或者没有tags属性的数据
    GET nulldb/test/_search
    {
      "query": {
        "bool": {
          "must_not": [
            {
              "exists":{
                "field":"tags"
              }
            }
          ]
        }
      }
    }